Updated to version 8.4.1

Added support for IOptions injection, allowing options to be read from IConfiguration
Small refactor on client options internals
Updated HttpClient to be static field to be

.github/workflows/dotnet.yml

@@ -0,0 +1,25 @@
+name: .NET
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v1
+      with:
+        dotnet-version: 8.0.x
+    - name: Restore dependencies
+      run: dotnet restore
+    - name: Build
+      run: dotnet build --no-restore
+    - name: Test
+      run: dotnet test --no-build --verbosity normal

.github/workflows/stale.yml

@@ -0,0 +1,31 @@
+# This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time.
+#
+# You can adjust the behavior by modifying this file.
+# For more information, see:
+# https://github.com/actions/stale
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+  - cron: '33 20 * * *'
+
+jobs:
+  stale:
+
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+
+    steps:
+    - uses: actions/stale@v3
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-issue-message: 'No activity on this issue for 60 days. This issue will get closed if it receives no update within 14 more days.'
+        stale-pr-message: 'No activity on this PR for 60 days. This PR will get closed if it receives no update within 14 more days.'
+        close-issue-message: 'Closed for inactivity. Feel free to update this if the issue is still relevant.'
+        close-pr-message: 'Closed for inactivity. Feel free to update this if the PR is still relevant.'
+        exempt-issue-labels: 'Future'
+        stale-issue-label: 'no-issue-activity'
+        stale-pr-label: 'no-pr-activity'
+        days-before-close: 14

.travis.yml

@@ -1,7 +0,0 @@
-language: csharp
-mono: none
-solution: CryptoExchange.Net.sln
-dotnet: 5.0.103
-script:
- - dotnet build CryptoExchange.Net/CryptoExchange.Net.csproj --framework "netstandard2.1"
- - dotnet test CryptoExchange.Net.UnitTests/CryptoExchange.Net.UnitTests.csproj

CryptoExchange.Net.UnitTests/AsyncResetEventTests.cs

@@ -1,5 +1,6 @@
 using CryptoExchange.Net.Objects;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -24,8 +25,8 @@ namespace CryptoExchange.Net.UnitTests
             var result1 = await waiter1;
             var result2 = await waiter2;
 
-            Assert.True(result1);
+            Assert.That(result1);
-            Assert.True(result2);
+            Assert.That(result2);
         }
 
         [Test]
@@ -39,8 +40,8 @@ namespace CryptoExchange.Net.UnitTests
             var result1 = await waiter1;
             var result2 = await waiter2;
 
-            Assert.True(result1);
+            Assert.That(result1);
-            Assert.True(result2);
+            Assert.That(result2);
         }
 
         [Test]
@@ -55,14 +56,14 @@ namespace CryptoExchange.Net.UnitTests
 
             var result1 = await waiter1;
 
-            Assert.True(result1);
+            Assert.That(result1);
-            Assert.True(waiter2.Status != TaskStatus.RanToCompletion);
+            Assert.That(waiter2.Status != TaskStatus.RanToCompletion);
 
             evnt.Set();
 
             var result2 = await waiter2;
 
-            Assert.True(result2);
+            Assert.That(result2);
         }
 
         [Test]
@@ -75,13 +76,13 @@ namespace CryptoExchange.Net.UnitTests
 
             var result1 = await waiter1;
 
-            Assert.True(result1);
+            Assert.That(result1);
-            Assert.True(waiter2.Status != TaskStatus.RanToCompletion);
+            Assert.That(waiter2.Status != TaskStatus.RanToCompletion);
             evnt.Set();
 
             var result2 = await waiter2;
 
-            Assert.True(result2);
+            Assert.That(result2);
         }
 
         [Test]
@@ -105,12 +106,12 @@ namespace CryptoExchange.Net.UnitTests
             for(var i = 1; i <= 10; i++)
             {
                 evnt.Set();
-                Assert.AreEqual(10 - i, waiters.Count(w => w.Status != TaskStatus.RanToCompletion));
+                Assert.That(10 - i == waiters.Count(w => w.Status != TaskStatus.RanToCompletion));
             }
 
             await resultsWaiter;
 
-            Assert.AreEqual(10, results.Count(r => r));
+            Assert.That(10 == results.Count(r => r));
         }
 
         [Test]
@@ -124,7 +125,7 @@ namespace CryptoExchange.Net.UnitTests
 
             var result1 = await waiter1;
 
-            Assert.True(result1);
+            Assert.That(result1);
         }
 
         [Test]
@@ -134,9 +135,9 @@ namespace CryptoExchange.Net.UnitTests
 
             var waiter1 = evnt.WaitAsync(TimeSpan.FromMilliseconds(100));
 
-            var result1 = await waiter1;            
+            var result1 = await waiter1;
 
-            Assert.False(result1);
+            ClassicAssert.False(result1);
         }
     }
 }

CryptoExchange.Net.UnitTests/BaseClientTests.cs

@@ -3,6 +3,7 @@ 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;
 
@@ -11,78 +12,6 @@ namespace CryptoExchange.Net.UnitTests
     [TestFixture()]
     public class BaseClientTests
     {
-        [TestCase(null, null)]
-        [TestCase("", "")]
-        [TestCase("test", null)]
-        [TestCase("test", "")]
-        [TestCase(null, "test")]
-        [TestCase("", "test")]
-        public void SettingEmptyValuesForAPICredentials_Should_ThrowException(string key, string secret)
-        {
-            // arrange
-            // act
-            // assert
-            Assert.Throws(typeof(ArgumentException), () => new TestBaseClient(new RestClientOptions("") { ApiCredentials = new ApiCredentials(key, secret) }));
-        }
-
-        [TestCase]
-        public void SettingLogOutput_Should_RedirectLogOutput()
-        {
-            // arrange
-            var logger = new TestStringLogger();
-            var client = new TestBaseClient(new RestClientOptions("")
-            {
-                LogWriters = new List<ILogger> { logger }
-            });
-
-            // act
-            client.Log(LogLevel.Information, "Test");
-
-            // assert
-            Assert.IsFalse(string.IsNullOrEmpty(logger.GetLogs()));
-        }
-
-        [TestCase(LogLevel.None, LogLevel.Error, false)]
-        [TestCase(LogLevel.None, LogLevel.Warning, false)]
-        [TestCase(LogLevel.None, LogLevel.Information, false)]
-        [TestCase(LogLevel.None, LogLevel.Debug, false)]
-        [TestCase(LogLevel.Error, LogLevel.Error, true)]
-        [TestCase(LogLevel.Error, LogLevel.Warning, false)]
-        [TestCase(LogLevel.Error, LogLevel.Information, false)]
-        [TestCase(LogLevel.Error, LogLevel.Debug, false)]
-        [TestCase(LogLevel.Warning, LogLevel.Error, true)]
-        [TestCase(LogLevel.Warning, LogLevel.Warning, true)]
-        [TestCase(LogLevel.Warning, LogLevel.Information, false)]
-        [TestCase(LogLevel.Warning, LogLevel.Debug, false)]
-        [TestCase(LogLevel.Information, LogLevel.Error, true)]
-        [TestCase(LogLevel.Information, LogLevel.Warning, true)]
-        [TestCase(LogLevel.Information, LogLevel.Information, true)]
-        [TestCase(LogLevel.Information, LogLevel.Debug, false)]
-        [TestCase(LogLevel.Debug, LogLevel.Error, true)]
-        [TestCase(LogLevel.Debug, LogLevel.Warning, true)]
-        [TestCase(LogLevel.Debug, LogLevel.Information, true)]
-        [TestCase(LogLevel.Debug, LogLevel.Debug, true)]
-        [TestCase(null, LogLevel.Error, true)]
-        [TestCase(null, LogLevel.Warning, true)]
-        [TestCase(null, LogLevel.Information, true)]
-        [TestCase(null, LogLevel.Debug, true)]
-        public void SettingLogLevel_Should_RestrictLogging(LogLevel? verbosity, LogLevel testVerbosity, bool expected)
-        {
-            // arrange
-            var logger = new TestStringLogger();
-            var client = new TestBaseClient(new RestClientOptions("")
-            {
-                LogWriters = new List<ILogger> { logger },
-                LogLevel = verbosity
-            });
-
-            // act
-            client.Log(testVerbosity, "Test");
-
-            // assert
-            Assert.AreEqual(!string.IsNullOrEmpty(logger.GetLogs()), expected);
-        }
-
         [TestCase]
         public void DeserializingValidJson_Should_GiveSuccessfulResult()
         {
@@ -90,10 +19,10 @@ namespace CryptoExchange.Net.UnitTests
             var client = new TestBaseClient();
 
             // act
-            var result = client.Deserialize<object>("{\"testProperty\": 123}");
+            var result = client.SubClient.Deserialize<object>("{\"testProperty\": 123}");
 
             // assert
-            Assert.IsTrue(result.Success);
+            Assert.That(result.Success);
         }
 
         [TestCase]
@@ -103,24 +32,24 @@ namespace CryptoExchange.Net.UnitTests
             var client = new TestBaseClient();
 
             // act
-            var result = client.Deserialize<object>("{\"testProperty\": 123");
+            var result = client.SubClient.Deserialize<object>("{\"testProperty\": 123");
 
             // assert
-            Assert.IsFalse(result.Success);
+            ClassicAssert.IsFalse(result.Success);
-            Assert.IsTrue(result.Error != null);
+            Assert.That(result.Error != null);
         }
 
-        [TestCase]
+        [TestCase("https://api.test.com/api", new[] { "path1", "path2" }, "https://api.test.com/api/path1/path2")]
-        public void FillingPathParameters_Should_ResultInValidUrl()
+        [TestCase("https://api.test.com/api", new[] { "path1", "/path2" }, "https://api.test.com/api/path1/path2")]
+        [TestCase("https://api.test.com/api", new[] { "path1/", "path2" }, "https://api.test.com/api/path1/path2")]
+        [TestCase("https://api.test.com/api", new[] { "path1/", "/path2" }, "https://api.test.com/api/path1/path2")]
+        [TestCase("https://api.test.com/api/", new[] { "path1", "path2" }, "https://api.test.com/api/path1/path2")]
+        [TestCase("https://api.test.com", new[] { "test-path/test-path" }, "https://api.test.com/test-path/test-path")]
+        [TestCase("https://api.test.com/", new[] { "test-path/test-path" }, "https://api.test.com/test-path/test-path")]
+        public void AppendPathTests(string baseUrl, string[] path, string expected)
         {
-            // arrange
+            var result = baseUrl.AppendPath(path);
-            var client = new TestBaseClient();
+            Assert.That(expected == result);
-
-            // act
-            var result = client.FillParameters("http://test.api/{}/path/{}", "1", "test");
-
-            // assert
-            Assert.IsTrue(result == "http://test.api/1/path/test");
         }
     }
 }

CryptoExchange.Net.UnitTests/CallResultTests.cs

@@ -0,0 +1,183 @@
+using CryptoExchange.Net.Objects;
+using NUnit.Framework;
+using NUnit.Framework.Legacy;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.UnitTests
+{
+    [TestFixture()]
+    internal class CallResultTests
+    {
+        [Test]
+        public void TestBasicErrorCallResult()
+        {
+            var result = new CallResult(new ServerError("TestError"));
+
+            ClassicAssert.AreSame(result.Error.Message, "TestError");
+            ClassicAssert.IsFalse(result);
+            ClassicAssert.IsFalse(result.Success);
+        }
+
+        [Test]
+        public void TestBasicSuccessCallResult()
+        {
+            var result = new CallResult(null);
+
+            ClassicAssert.IsNull(result.Error);
+            Assert.That(result);
+            Assert.That(result.Success);
+        }
+
+        [Test]
+        public void TestCallResultError()
+        {
+            var result = new CallResult<object>(new ServerError("TestError"));
+
+            ClassicAssert.AreSame(result.Error.Message, "TestError");
+            ClassicAssert.IsNull(result.Data);
+            ClassicAssert.IsFalse(result);
+            ClassicAssert.IsFalse(result.Success);
+        }
+
+        [Test]
+        public void TestCallResultSuccess()
+        {
+            var result = new CallResult<object>(new object());
+
+            ClassicAssert.IsNull(result.Error);
+            ClassicAssert.IsNotNull(result.Data);
+            Assert.That(result);
+            Assert.That(result.Success);
+        }
+
+        [Test]
+        public void TestCallResultSuccessAs()
+        {
+            var result = new CallResult<TestObjectResult>(new TestObjectResult());
+            var asResult = result.As<TestObject2>(result.Data.InnerData);
+
+            ClassicAssert.IsNull(asResult.Error);
+            ClassicAssert.IsNotNull(asResult.Data);
+            Assert.That(asResult.Data is not null);
+            Assert.That(asResult);
+            Assert.That(asResult.Success);
+        }
+
+        [Test]
+        public void TestCallResultErrorAs()
+        {
+            var result = new CallResult<TestObjectResult>(new ServerError("TestError"));
+            var asResult = result.As<TestObject2>(default);
+
+            ClassicAssert.IsNotNull(asResult.Error);
+            ClassicAssert.AreSame(asResult.Error.Message, "TestError");
+            ClassicAssert.IsNull(asResult.Data);
+            ClassicAssert.IsFalse(asResult);
+            ClassicAssert.IsFalse(asResult.Success);
+        }
+
+        [Test]
+        public void TestCallResultErrorAsError()
+        {
+            var result = new CallResult<TestObjectResult>(new ServerError("TestError"));
+            var asResult = result.AsError<TestObject2>(new ServerError("TestError2"));
+
+            ClassicAssert.IsNotNull(asResult.Error);
+            ClassicAssert.AreSame(asResult.Error.Message, "TestError2");
+            ClassicAssert.IsNull(asResult.Data);
+            ClassicAssert.IsFalse(asResult);
+            ClassicAssert.IsFalse(asResult.Success);
+        }
+
+        [Test]
+        public void TestWebCallResultErrorAsError()
+        {
+            var result = new WebCallResult<TestObjectResult>(new ServerError("TestError"));
+            var asResult = result.AsError<TestObject2>(new ServerError("TestError2"));
+
+            ClassicAssert.IsNotNull(asResult.Error);
+            ClassicAssert.AreSame(asResult.Error.Message, "TestError2");
+            ClassicAssert.IsNull(asResult.Data);
+            ClassicAssert.IsFalse(asResult);
+            ClassicAssert.IsFalse(asResult.Success);
+        }
+
+        [Test]
+        public void TestWebCallResultSuccessAsError()
+        {
+            var result = new WebCallResult<TestObjectResult>(
+                System.Net.HttpStatusCode.OK,
+                new List<KeyValuePair<string, IEnumerable<string>>>(),
+                TimeSpan.FromSeconds(1),
+                null,
+                "{}",
+                1,
+                "https://test.com/api",
+                null,
+                HttpMethod.Get,
+                new List<KeyValuePair<string, IEnumerable<string>>>(),
+                ResultDataSource.Server,
+                new TestObjectResult(),
+                null);
+            var asResult = result.AsError<TestObject2>(new ServerError("TestError2"));
+
+            ClassicAssert.IsNotNull(asResult.Error);
+            Assert.That(asResult.Error.Message == "TestError2");
+            Assert.That(asResult.ResponseStatusCode == System.Net.HttpStatusCode.OK);
+            Assert.That(asResult.ResponseTime == TimeSpan.FromSeconds(1));
+            Assert.That(asResult.RequestUrl == "https://test.com/api");
+            Assert.That(asResult.RequestMethod == HttpMethod.Get);
+            ClassicAssert.IsNull(asResult.Data);
+            ClassicAssert.IsFalse(asResult);
+            ClassicAssert.IsFalse(asResult.Success);
+        }
+
+        [Test]
+        public void TestWebCallResultSuccessAsSuccess()
+        {
+            var result = new WebCallResult<TestObjectResult>(
+                System.Net.HttpStatusCode.OK,
+                new List<KeyValuePair<string, IEnumerable<string>>>(),
+                TimeSpan.FromSeconds(1),
+                null,
+                "{}",
+                1,
+                "https://test.com/api",
+                null,
+                HttpMethod.Get,
+                new List<KeyValuePair<string, IEnumerable<string>>>(),
+                ResultDataSource.Server,
+                new TestObjectResult(),
+                null);
+            var asResult = result.As<TestObject2>(result.Data.InnerData);
+
+            ClassicAssert.IsNull(asResult.Error);
+            Assert.That(asResult.ResponseStatusCode == System.Net.HttpStatusCode.OK);
+            Assert.That(asResult.ResponseTime == TimeSpan.FromSeconds(1));
+            Assert.That(asResult.RequestUrl == "https://test.com/api");
+            Assert.That(asResult.RequestMethod == HttpMethod.Get);
+            ClassicAssert.IsNotNull(asResult.Data);
+            Assert.That(asResult);
+            Assert.That(asResult.Success);
+        }
+    }
+
+    public class TestObjectResult
+    {
+        public TestObject2 InnerData;
+
+        public TestObjectResult()
+        {
+            InnerData = new TestObject2();
+        }
+    }
+
+    public class TestObject2
+    {
+    }
+}

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

@@ -1,15 +1,15 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp5.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <packagereference Include="Microsoft.NET.Test.Sdk" Version="16.10.0"></packagereference>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0"></PackageReference>
-    <PackageReference Include="Moq" Version="4.16.1" />
+    <PackageReference Include="Moq" Version="4.20.72" />
-    <packagereference Include="NUnit" Version="3.13.2"></packagereference>
+    <PackageReference Include="NUnit" Version="4.2.2"></PackageReference>
-    <packagereference Include="NUnit3TestAdapter" Version="3.17.0"></packagereference>
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0"></PackageReference>
   </ItemGroup>
 
   <ItemGroup>

CryptoExchange.Net.UnitTests/ExchangeHelpersTests.cs

@@ -1,5 +1,7 @@
 using CryptoExchange.Net.Objects;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
+using System.Diagnostics;
 using System.Globalization;
 
 namespace CryptoExchange.Net.UnitTests
@@ -16,7 +18,7 @@ namespace CryptoExchange.Net.UnitTests
         public void ClampValueTests(decimal min, decimal max, decimal input, decimal expected)
         {
             var result = ExchangeHelpers.ClampValue(min, max, input);
-            Assert.AreEqual(expected, result);
+            Assert.That(expected == result);
         }
 
         [TestCase(0.1, 1, 0.1, RoundingType.Down, 0.4, 0.4)]
@@ -33,7 +35,7 @@ namespace CryptoExchange.Net.UnitTests
         public void AdjustValueStepTests(decimal min, decimal max, decimal? step, RoundingType roundingType, decimal input, decimal expected)
         {
             var result = ExchangeHelpers.AdjustValueStep(min, max, step, roundingType, input);
-            Assert.AreEqual(expected, result);
+            Assert.That(expected == result);
         }
 
         [TestCase(0.1, 1, 2, RoundingType.Closest, 0.4, 0.4)]
@@ -48,7 +50,7 @@ namespace CryptoExchange.Net.UnitTests
         public void AdjustValuePrecisionTests(decimal min, decimal max, int? precision, RoundingType roundingType, decimal input, decimal expected)
         {
             var result = ExchangeHelpers.AdjustValuePrecision(min, max, precision, roundingType, input);
-            Assert.AreEqual(expected, result);
+            Assert.That(expected == result);
         }
 
         [TestCase(5, 0.1563158, 0.15631)]
@@ -59,7 +61,7 @@ namespace CryptoExchange.Net.UnitTests
         public void RoundDownTests(int decimalPlaces, decimal input, decimal expected)
         {
             var result = ExchangeHelpers.RoundDown(input, decimalPlaces);
-            Assert.AreEqual(expected, result);
+            Assert.That(expected == result);
         }
 
         [TestCase(0.1234560000, "0.123456")]
@@ -67,7 +69,22 @@ namespace CryptoExchange.Net.UnitTests
         public void NormalizeTests(decimal input, string expected)
         {
             var result = ExchangeHelpers.Normalize(input);
-            Assert.AreEqual(expected, result.ToString(CultureInfo.InvariantCulture));
+            Assert.That(expected == result.ToString(CultureInfo.InvariantCulture));
+        }
+
+        [Test]
+        [TestCase("123", "BKR", 32, true, "BKR|JK|123")]
+        [TestCase("123", "BKR", 32, false, "123")]
+        [TestCase("123123123123123123123123123123", "BKR", 32, true, "123123123123123123123123123123")] // 30
+        [TestCase("123123123123123123123123123", "BKR", 32, true, "123123123123123123123123123")] // 27
+        [TestCase("1231231231231231231231231", "BKR", 32, true, "BKR|JK|1231231231231231231231231")] // 25
+        [TestCase(null, "BKR", 32, true, null)]
+        public void ApplyBrokerIdTests(string clientOrderId, string brokerId, int maxLength, bool allowValueAdjustement, string expected)
+        {
+            var result = LibraryHelpers.ApplyBrokerId(clientOrderId, brokerId, maxLength, allowValueAdjustement);
+            
+            if (expected != null)
+                Assert.That(result, Is.EqualTo(expected));
         }
     }
 }

CryptoExchange.Net.UnitTests/JsonNetConverterTests.cs

@@ -0,0 +1,248 @@
+using CryptoExchange.Net.Attributes;
+using CryptoExchange.Net.Converters;
+using CryptoExchange.Net.Converters.JsonNet;
+using Newtonsoft.Json;
+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
+{
+    [TestFixture()]
+    public class JsonNetConverterTests
+    {
+        [TestCase("2021-05-12")]
+        [TestCase("20210512")]
+        [TestCase("210512")]
+        [TestCase("1620777600.000")]
+        [TestCase("1620777600000")]
+        [TestCase("2021-05-12T00:00:00.000Z")]
+        [TestCase("2021-05-12T00:00:00.000000000Z")]
+        [TestCase("0.000000", true)]
+        [TestCase("0", true)]
+        [TestCase("", true)]
+        [TestCase("  ", true)]
+        public void TestDateTimeConverterString(string input, bool expectNull = false)
+        {
+            var output = JsonConvert.DeserializeObject<TimeObject>($"{{ \"time\": \"{input}\" }}");
+            Assert.That(output.Time == (expectNull ? null: new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc)));
+        }
+
+        [TestCase(1620777600.000)]
+        [TestCase(1620777600000d)]
+        public void TestDateTimeConverterDouble(double input)
+        {
+            var output = JsonConvert.DeserializeObject<TimeObject>($"{{ \"time\": {input} }}");
+            Assert.That(output.Time == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [TestCase(1620777600)]
+        [TestCase(1620777600000)]
+        [TestCase(1620777600000000)]
+        [TestCase(1620777600000000000)]
+        [TestCase(0, true)]
+        public void TestDateTimeConverterLong(long input, bool expectNull = false)
+        {
+            var output = JsonConvert.DeserializeObject<TimeObject>($"{{ \"time\": {input} }}");
+            Assert.That(output.Time == (expectNull ? null : new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc)));
+        }
+
+        [TestCase(1620777600)]
+        [TestCase(1620777600.000)]
+        public void TestDateTimeConverterFromSeconds(double input)
+        {
+            var output = DateTimeConverter.ConvertFromSeconds(input);
+            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToSeconds()
+        {
+            var output = DateTimeConverter.ConvertToSeconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(output == 1620777600);
+        }
+
+        [TestCase(1620777600000)]
+        [TestCase(1620777600000.000)]
+        public void TestDateTimeConverterFromMilliseconds(double input)
+        {
+            var output = DateTimeConverter.ConvertFromMilliseconds(input);
+            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToMilliseconds()
+        {
+            var output = DateTimeConverter.ConvertToMilliseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(output == 1620777600000);
+        }
+
+        [TestCase(1620777600000000)]
+        public void TestDateTimeConverterFromMicroseconds(long input)
+        {
+            var output = DateTimeConverter.ConvertFromMicroseconds(input);
+            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToMicroseconds()
+        {
+            var output = DateTimeConverter.ConvertToMicroseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(output == 1620777600000000);
+        }
+
+        [TestCase(1620777600000000000)]
+        public void TestDateTimeConverterFromNanoseconds(long input)
+        {
+            var output = DateTimeConverter.ConvertFromNanoseconds(input);
+            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToNanoseconds()
+        {
+            var output = DateTimeConverter.ConvertToNanoseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(output == 1620777600000000000);
+        }
+
+        [TestCase()]
+        public void TestDateTimeConverterNull()
+        {
+            var output = JsonConvert.DeserializeObject<TimeObject>($"{{ \"time\": null }}");
+            Assert.That(output.Time == null);
+        }
+
+        [TestCase(TestEnum.One, "1")]
+        [TestCase(TestEnum.Two, "2")]
+        [TestCase(TestEnum.Three, "three")]
+        [TestCase(TestEnum.Four, "Four")]
+        [TestCase(null, null)]
+        public void TestEnumConverterNullableGetStringTests(TestEnum? value, string expected)
+        {
+            var output = EnumConverter.GetString(value);
+            Assert.That(output == expected);
+        }
+
+        [TestCase(TestEnum.One, "1")]
+        [TestCase(TestEnum.Two, "2")]
+        [TestCase(TestEnum.Three, "three")]
+        [TestCase(TestEnum.Four, "Four")]
+        public void TestEnumConverterGetStringTests(TestEnum value, string expected)
+        {
+            var output = EnumConverter.GetString(value);
+            Assert.That(output == expected);
+        }
+
+        [TestCase("1", TestEnum.One)]
+        [TestCase("2", TestEnum.Two)]
+        [TestCase("3", TestEnum.Three)]
+        [TestCase("three", TestEnum.Three)]
+        [TestCase("Four", TestEnum.Four)]
+        [TestCase("four", TestEnum.Four)]
+        [TestCase("Four1", null)]
+        [TestCase(null, null)]
+        public void TestEnumConverterNullableDeserializeTests(string value, TestEnum? expected)
+        {
+            var val = value == null ? "null" : $"\"{value}\"";
+            var output = JsonConvert.DeserializeObject<EnumObject>($"{{ \"Value\": {val} }}");
+            Assert.That(output.Value == expected);
+        }
+
+        [TestCase("1", TestEnum.One)]
+        [TestCase("2", TestEnum.Two)]
+        [TestCase("3", TestEnum.Three)]
+        [TestCase("three", TestEnum.Three)]
+        [TestCase("Four", TestEnum.Four)]
+        [TestCase("four", TestEnum.Four)]
+        [TestCase("Four1", TestEnum.One)]
+        [TestCase(null, TestEnum.One)]
+        public void TestEnumConverterNotNullableDeserializeTests(string value, TestEnum? expected)
+        {
+            var val = value == null ? "null" : $"\"{value}\"";
+            var output = JsonConvert.DeserializeObject<NotNullableEnumObject>($"{{ \"Value\": {val} }}");
+            Assert.That(output.Value == expected);
+        }
+
+        [TestCase("1", true)]
+        [TestCase("true", true)]
+        [TestCase("yes", true)]
+        [TestCase("y", true)]
+        [TestCase("on", true)]
+        [TestCase("-1", false)]
+        [TestCase("0", false)]
+        [TestCase("n", false)]
+        [TestCase("no", false)]
+        [TestCase("false", false)]
+        [TestCase("off", false)]
+        [TestCase("", null)]
+        public void TestBoolConverter(string value, bool? expected)
+        {
+            var val = value == null ? "null" : $"\"{value}\"";
+            var output = JsonConvert.DeserializeObject<BoolObject>($"{{ \"Value\": {val} }}");
+            Assert.That(output.Value == expected);
+        }
+
+        [TestCase("1", true)]
+        [TestCase("true", true)]
+        [TestCase("yes", true)]
+        [TestCase("y", true)]
+        [TestCase("on", true)]
+        [TestCase("-1", false)]
+        [TestCase("0", false)]
+        [TestCase("n", false)]
+        [TestCase("no", false)]
+        [TestCase("false", false)]
+        [TestCase("off", false)]
+        [TestCase("", false)]
+        public void TestBoolConverterNotNullable(string value, bool expected)
+        {
+            var val = value == null ? "null" : $"\"{value}\"";
+            var output = JsonConvert.DeserializeObject<NotNullableBoolObject>($"{{ \"Value\": {val} }}");
+            Assert.That(output.Value == expected);
+        }
+    }
+
+    public class TimeObject
+    {
+        [JsonConverter(typeof(DateTimeConverter))]
+        public DateTime? Time { get; set; }
+    }
+
+    public class EnumObject
+    {
+        public TestEnum? Value { get; set; }
+    }
+
+    public class NotNullableEnumObject
+    {
+        public TestEnum Value { get; set; }
+    }
+
+    public class BoolObject
+    {
+        [JsonConverter(typeof(BoolConverter))]
+        public bool? Value { get; set; }
+    }
+
+    public class NotNullableBoolObject
+    {
+        [JsonConverter(typeof(BoolConverter))]
+        public bool Value { get; set; }
+    }
+
+    [JsonConverter(typeof(EnumConverter))]
+    public enum TestEnum
+    {
+        [Map("1")]
+        One,
+        [Map("2")]
+        Two,
+        [Map("three", "3")]
+        Three,
+        Four
+    }
+}

CryptoExchange.Net.UnitTests/OptionsTests.cs

@@ -0,0 +1,170 @@
+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
+{
+    [TestFixture()]
+    public class OptionsTests
+    {
+        [TearDown]
+        public void Init()
+        {
+            TestClientOptions.Default = new TestClientOptions
+            {
+            };
+        }
+
+        [TestCase(null, null)]
+        [TestCase("", "")]
+        [TestCase("test", null)]
+        [TestCase("test", "")]
+        [TestCase(null, "test")]
+        [TestCase("", "test")]
+        public void SettingEmptyValuesForAPICredentials_Should_ThrowException(string key, string secret)
+        {
+            // arrange
+            // act
+            // assert
+            Assert.Throws(typeof(ArgumentException),
+                () => new RestExchangeOptions<TestEnvironment, ApiCredentials>() { ApiCredentials = new ApiCredentials(key, secret) });
+        }
+
+        [Test]
+        public void TestBasicOptionsAreSet()
+        {
+            // arrange, act
+            var options = new TestClientOptions
+            {
+                ApiCredentials = new ApiCredentials("123", "456"),
+                ReceiveWindow = TimeSpan.FromSeconds(10)
+            };
+
+            // assert
+            Assert.That(options.ReceiveWindow == TimeSpan.FromSeconds(10));
+            Assert.That(options.ApiCredentials.Key == "123");
+            Assert.That(options.ApiCredentials.Secret == "456");
+        }
+
+        [Test]
+        public void TestApiOptionsAreSet()
+        {
+            // arrange, act
+            var options = new TestClientOptions();
+            options.Api1Options.ApiCredentials = new ApiCredentials("123", "456");
+            options.Api2Options.ApiCredentials = new ApiCredentials("789", "101");
+
+            // assert
+            Assert.That(options.Api1Options.ApiCredentials.Key == "123");
+            Assert.That(options.Api1Options.ApiCredentials.Secret == "456");
+            Assert.That(options.Api2Options.ApiCredentials.Key == "789");
+            Assert.That(options.Api2Options.ApiCredentials.Secret == "101");
+        }
+
+        [Test]
+        public void TestClientUsesCorrectOptions()
+        {
+            var client = new TestRestClient(options => {
+                options.Api1Options.ApiCredentials = new ApiCredentials("111", "222");
+                options.ApiCredentials = new ApiCredentials("333", "444");
+            });
+
+            var authProvider1 = (TestAuthProvider)client.Api1.AuthenticationProvider;
+            var authProvider2 = (TestAuthProvider)client.Api2.AuthenticationProvider;
+            Assert.That(authProvider1.GetKey() == "111");
+            Assert.That(authProvider1.GetSecret() == "222");
+            Assert.That(authProvider2.GetKey() == "333");
+            Assert.That(authProvider2.GetSecret() == "444");
+        }
+
+        [Test]
+        public void TestClientUsesCorrectOptionsWithDefault()
+        {
+            TestClientOptions.Default.ApiCredentials = new ApiCredentials("123", "456");
+            TestClientOptions.Default.Api1Options.ApiCredentials = new ApiCredentials("111", "222");
+
+            var client = new TestRestClient();
+
+            var authProvider1 = (TestAuthProvider)client.Api1.AuthenticationProvider;
+            var authProvider2 = (TestAuthProvider)client.Api2.AuthenticationProvider;
+            Assert.That(authProvider1.GetKey() == "111");
+            Assert.That(authProvider1.GetSecret() == "222");
+            Assert.That(authProvider2.GetKey() == "123");
+            Assert.That(authProvider2.GetSecret() == "456");
+
+            // Cleanup static values
+            TestClientOptions.Default.ApiCredentials = null;
+            TestClientOptions.Default.Api1Options.ApiCredentials = null;
+        }
+
+        [Test]
+        public void TestClientUsesCorrectOptionsWithOverridingDefault()
+        {
+            TestClientOptions.Default.ApiCredentials = new ApiCredentials("123", "456");
+            TestClientOptions.Default.Api1Options.ApiCredentials = new ApiCredentials("111", "222");
+
+            var client = new TestRestClient(options =>
+            {
+                options.Api1Options.ApiCredentials = new ApiCredentials("333", "444");
+                options.Environment = new TestEnvironment("Test", "https://test.test");
+            });
+
+            var authProvider1 = (TestAuthProvider)client.Api1.AuthenticationProvider;
+            var authProvider2 = (TestAuthProvider)client.Api2.AuthenticationProvider;
+            Assert.That(authProvider1.GetKey() == "333");
+            Assert.That(authProvider1.GetSecret() == "444");
+            Assert.That(authProvider2.GetKey() == "123");
+            Assert.That(authProvider2.GetSecret() == "456");
+            Assert.That(client.Api2.BaseAddress == "https://localhost:123");
+
+            // Cleanup static values
+            TestClientOptions.Default.ApiCredentials = null;
+            TestClientOptions.Default.Api1Options.ApiCredentials = null;
+        }
+    }
+
+    public class TestClientOptions: RestExchangeOptions<TestEnvironment, ApiCredentials>
+    {
+        /// <summary>
+        /// Default options for the futures client
+        /// </summary>
+        public static TestClientOptions Default { get; set; } = new TestClientOptions()
+        {
+            Environment = new TestEnvironment("test", "https://test.com")
+        };
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public TestClientOptions()
+        {
+            Default?.Set(this);
+        }
+
+        /// <summary>
+        /// The default receive window for requests
+        /// </summary>
+        public TimeSpan ReceiveWindow { get; set; } = TimeSpan.FromSeconds(5);
+
+        public RestApiOptions Api1Options { get; private set; } = new RestApiOptions();
+
+        public RestApiOptions Api2Options { get; set; } = new RestApiOptions();
+
+        internal TestClientOptions Set(TestClientOptions targetOptions)
+        {
+            targetOptions = base.Set<TestClientOptions>(targetOptions);
+            targetOptions.Api1Options = Api1Options.Set(targetOptions.Api1Options);
+            targetOptions.Api2Options = Api2Options.Set(targetOptions.Api2Options);
+            return targetOptions;
+        }
+    }
+}

CryptoExchange.Net.UnitTests/RestClientTests.cs

@@ -8,10 +8,16 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.RateLimiter;
 using Microsoft.Extensions.Logging;
 using System.Net.Http;
 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;
 
 namespace CryptoExchange.Net.UnitTests
 {
@@ -27,11 +33,11 @@ namespace CryptoExchange.Net.UnitTests
             client.SetResponse(JsonConvert.SerializeObject(expected), out _);
 
             // act
-            var result = client.Request<TestObject>().Result;
+            var result = client.Api1.Request<TestObject>().Result;
 
             // assert
-            Assert.IsTrue(result.Success);
+            Assert.That(result.Success);
-            Assert.IsTrue(TestHelpers.AreEqual(expected, result.Data));
+            Assert.That(TestHelpers.AreEqual(expected, result.Data));
         }
 
         [TestCase]
@@ -42,62 +48,62 @@ namespace CryptoExchange.Net.UnitTests
             client.SetResponse("{\"property\": 123", out _);
 
             // act
-            var result = client.Request<TestObject>().Result;
+            var result = client.Api1.Request<TestObject>().Result;
 
             // assert
-            Assert.IsFalse(result.Success);
+            ClassicAssert.IsFalse(result.Success);
-            Assert.IsTrue(result.Error != null);
+            Assert.That(result.Error != null);
         }
 
         [TestCase]
-        public void ReceivingErrorCode_Should_ResultInError()
+        public async Task ReceivingErrorCode_Should_ResultInError()
         {
             // arrange
             var client = new TestRestClient();
             client.SetErrorWithoutResponse(System.Net.HttpStatusCode.BadRequest, "Invalid request");
 
             // act
-            var result = client.Request<TestObject>().Result;
+            var result = await client.Api1.Request<TestObject>();
 
             // assert
-            Assert.IsFalse(result.Success);
+            ClassicAssert.IsFalse(result.Success);
-            Assert.IsTrue(result.Error != null);
+            Assert.That(result.Error != null);
         }
 
         [TestCase]
-        public void ReceivingErrorAndNotParsingError_Should_ResultInFlatError()
+        public async Task ReceivingErrorAndNotParsingError_Should_ResultInFlatError()
         {
             // arrange
             var client = new TestRestClient();
             client.SetErrorWithResponse("{\"errorMessage\": \"Invalid request\", \"errorCode\": 123}", System.Net.HttpStatusCode.BadRequest);
 
             // act
-            var result = client.Request<TestObject>().Result;
+            var result = await client.Api1.Request<TestObject>();
 
             // assert
-            Assert.IsFalse(result.Success);
+            ClassicAssert.IsFalse(result.Success);
-            Assert.IsTrue(result.Error != null);
+            Assert.That(result.Error != null);
-            Assert.IsTrue(result.Error is ServerError);
+            Assert.That(result.Error is ServerError);
-            Assert.IsTrue(result.Error.Message.Contains("Invalid request"));
+            Assert.That(result.Error.Message.Contains("Invalid request"));
-            Assert.IsTrue(result.Error.Message.Contains("123"));
+            Assert.That(result.Error.Message.Contains("123"));
         }
 
         [TestCase]
-        public void ReceivingErrorAndParsingError_Should_ResultInParsedError()
+        public async Task ReceivingErrorAndParsingError_Should_ResultInParsedError()
         {
             // arrange
             var client = new ParseErrorTestRestClient();
             client.SetErrorWithResponse("{\"errorMessage\": \"Invalid request\", \"errorCode\": 123}", System.Net.HttpStatusCode.BadRequest);
 
             // act
-            var result = client.Request<TestObject>().Result;
+            var result = await client.Api2.Request<TestObject>();
 
             // assert
-            Assert.IsFalse(result.Success);
+            ClassicAssert.IsFalse(result.Success);
-            Assert.IsTrue(result.Error != null);
+            Assert.That(result.Error != null);
-            Assert.IsTrue(result.Error is ServerError);
+            Assert.That(result.Error is ServerError);
-            Assert.IsTrue(result.Error.Code == 123);
+            Assert.That(result.Error.Code == 123);
-            Assert.IsTrue(result.Error.Message == "Invalid request");
+            Assert.That(result.Error.Message == "Invalid request");
         }
 
         [TestCase]
@@ -105,20 +111,16 @@ namespace CryptoExchange.Net.UnitTests
         {
             // arrange
             // act
-            var client = new TestRestClient(new RestClientOptions("")
+            var options = new TestClientOptions();
-            {
+            options.Api1Options.TimestampRecalculationInterval = TimeSpan.FromMinutes(10);
-                BaseAddress = "http://test.address.com",
+            options.Api1Options.OutputOriginalData = true;
-                RateLimiters = new List<IRateLimiter>{new RateLimiterTotal(1, TimeSpan.FromSeconds(1))},
+            options.RequestTimeout = TimeSpan.FromMinutes(1);
-                RateLimitingBehaviour = RateLimitingBehaviour.Fail,
+            var client = new TestBaseClient(options);
-                RequestTimeout = TimeSpan.FromMinutes(1)
-            });
-
 
             // assert
-            Assert.IsTrue(client.BaseAddress == "http://test.address.com/");
+            Assert.That(((TestClientOptions)client.ClientOptions).Api1Options.TimestampRecalculationInterval == TimeSpan.FromMinutes(10));
-            Assert.IsTrue(client.RateLimiters.Count() == 1);
+            Assert.That(((TestClientOptions)client.ClientOptions).Api1Options.OutputOriginalData == true);
-            Assert.IsTrue(client.RateLimitBehaviour == RateLimitingBehaviour.Fail);
+            Assert.That(((TestClientOptions)client.ClientOptions).RequestTimeout == TimeSpan.FromMinutes(1));
-            Assert.IsTrue(client.RequestTimeout == TimeSpan.FromMinutes(1));
         }
 
         [TestCase("GET", HttpMethodParameterPosition.InUri)] // No need to test InBody for GET since thats not valid
@@ -132,16 +134,13 @@ namespace CryptoExchange.Net.UnitTests
         {
             // arrange
             // act
-            var client = new TestRestClient(new RestClientOptions("")
+            var client = new TestRestClient();
-            {
-                BaseAddress = "http://test.address.com",
-            });
 
-            client.SetParameterPosition(new HttpMethod(method), pos);
+            client.Api1.SetParameterPosition(new HttpMethod(method), pos);
 
             client.SetResponse("{}", out var request);
 
-            await client.RequestWithParams<TestObject>(new HttpMethod(method), new Dictionary<string, object>
+            await client.Api1.RequestWithParams<TestObject>(new HttpMethod(method), new Dictionary<string, object>
             {
                 { "TestParam1", "Value1" },
                 { "TestParam2", 2 },
@@ -152,93 +151,239 @@ namespace CryptoExchange.Net.UnitTests
             });
 
             // assert
-            Assert.AreEqual(request.Method, new HttpMethod(method));
+            Assert.That(request.Method == new HttpMethod(method));
-            Assert.AreEqual(request.Content?.Contains("TestParam1") == true, pos == HttpMethodParameterPosition.InBody);
+            Assert.That((request.Content?.Contains("TestParam1") == true) == (pos == HttpMethodParameterPosition.InBody));
-            Assert.AreEqual(request.Uri.ToString().Contains("TestParam1"), pos == HttpMethodParameterPosition.InUri);
+            Assert.That((request.Uri.ToString().Contains("TestParam1")) == (pos == HttpMethodParameterPosition.InUri));
-            Assert.AreEqual(request.Content?.Contains("TestParam2") == true, pos == HttpMethodParameterPosition.InBody);
+            Assert.That((request.Content?.Contains("TestParam2") == true) == (pos == HttpMethodParameterPosition.InBody));
-            Assert.AreEqual(request.Uri.ToString().Contains("TestParam2"), pos == HttpMethodParameterPosition.InUri);
+            Assert.That((request.Uri.ToString().Contains("TestParam2")) == (pos == HttpMethodParameterPosition.InUri));
-            Assert.AreEqual(request.GetHeaders().First().Key, "TestHeader");
+            Assert.That(request.GetHeaders().First().Key == "TestHeader");
-            Assert.IsTrue(request.GetHeaders().First().Value.Contains("123"));
+            Assert.That(request.GetHeaders().First().Value.Contains("123"));
         }
 
-        [TestCase]
+
-        public void SettingRateLimitingBehaviourToFail_Should_FailLimitedRequests()
+        [TestCase(1, 0.1)]
+        [TestCase(2, 0.1)]
+        [TestCase(5, 1)]
+        [TestCase(1, 2)]
+        public async Task PartialEndpointRateLimiterBasics(int requests, double perSeconds)
         {
-            // arrange
+            var rateLimiter = new RateLimitGate("Test");
-            var client = new TestRestClient(new RestClientOptions("")
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, new PathStartFilter("/sapi/"), requests, TimeSpan.FromSeconds(perSeconds), RateLimitWindowType.Fixed));
+
+            var triggered = false;
+            rateLimiter.RateLimitTriggered += (x) => { triggered = true; };
+            var requestDefinition = new RequestDefinition("/sapi/v1/system/status", HttpMethod.Get);
+
+            for (var i = 0; i < requests + 1; i++)
             {
-                RateLimiters = new List<IRateLimiter> { new RateLimiterTotal(1, TimeSpan.FromSeconds(1)) },
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);             
-                RateLimitingBehaviour = RateLimitingBehaviour.Fail
+                Assert.That(i == requests? triggered : !triggered);
-            });
+            }
-            client.SetResponse("{\"property\": 123}", out _);
+            triggered = false;
-
+            await Task.Delay((int)Math.Round(perSeconds * 1000) + 10);
-
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1,  RateLimitingBehaviour.Wait, default);
-            // act
+            Assert.That(!triggered);
-            var result1 = client.Request<TestObject>().Result;
-            client.SetResponse("{\"property\": 123}", out _);
-            var result2 = client.Request<TestObject>().Result;
-
-
-            // assert
-            Assert.IsTrue(result1.Success);
-            Assert.IsFalse(result2.Success);
         }
 
-        [TestCase]
+        [TestCase("/sapi/test1", true)]
-        public void SettingRateLimitingBehaviourToWait_Should_DelayLimitedRequests()
+        [TestCase("/sapi/test2", true)]
+        [TestCase("/api/test1", false)]
+        [TestCase("sapi/test1", false)]
+        [TestCase("/sapi/", true)]
+        public async Task PartialEndpointRateLimiterEndpoints(string endpoint, bool expectLimiting)
         {
-            // arrange
+            var rateLimiter = new RateLimitGate("Test");
-            var client = new TestRestClient(new RestClientOptions("")
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, new PathStartFilter("/sapi/"), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
+
+            var requestDefinition = new RequestDefinition(endpoint, HttpMethod.Get);
+
+            RateLimitEvent evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
+            for (var i = 0; i < 2; i++)
             {
-                RateLimiters = new List<IRateLimiter> { new RateLimiterTotal(1, TimeSpan.FromSeconds(1)) },
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
-                RateLimitingBehaviour = RateLimitingBehaviour.Wait
+                bool expected = i == 1 ? (expectLimiting ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
-            });
+                Assert.That(expected);
-            client.SetResponse("{\"property\": 123}", out _);
+            }
-
-
-            // act
-            var sw = Stopwatch.StartNew();
-            var result1 = client.Request<TestObject>().Result;
-            client.SetResponse("{\"property\": 123}", out _); // reset response stream
-            var result2 = client.Request<TestObject>().Result;
-            sw.Stop();
-
-            // assert
-            Assert.IsTrue(result1.Success);
-            Assert.IsTrue(result2.Success);
-            Assert.IsTrue(sw.ElapsedMilliseconds > 900, $"Actual: {sw.ElapsedMilliseconds}");
         }
 
-        [TestCase]
+        [TestCase("/sapi/", "/sapi/", true)]
-        public void SettingApiKeyRateLimiter_Should_DelayRequestsFromSameKey()
+        [TestCase("/sapi/test", "/sapi/test", true)]
+        [TestCase("/sapi/test", "/sapi/test123", false)]
+        [TestCase("/sapi/test", "/sapi/", false)]
+        public async Task PartialEndpointRateLimiterEndpoints(string endpoint1, string endpoint2, bool expectLimiting)
         {
-            // arrange
+            var rateLimiter = new RateLimitGate("Test");
-            var client = new TestRestClient(new RestClientOptions("")
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerEndpoint, new PathStartFilter("/sapi/"), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
+
+            var requestDefinition1 = new RequestDefinition(endpoint1, HttpMethod.Get);
+            var requestDefinition2 = new RequestDefinition(endpoint2, HttpMethod.Get);
+
+            RateLimitEvent evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
+
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(evnt == null);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(expectLimiting ? evnt != null : evnt == null);
+        }
+
+        [TestCase(1, 0.1)]
+        [TestCase(2, 0.1)]
+        [TestCase(5, 1)]
+        [TestCase(1, 2)]
+        public async Task EndpointRateLimiterBasics(int requests, double perSeconds)
+        {
+            var rateLimiter = new RateLimitGate("Test");
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerEndpoint, new PathStartFilter("/sapi/test"), requests, TimeSpan.FromSeconds(perSeconds), RateLimitWindowType.Fixed));
+
+            bool triggered = false;
+            rateLimiter.RateLimitTriggered += (x) => { triggered = true; };
+            var requestDefinition = new RequestDefinition("/sapi/test", HttpMethod.Get);
+
+            for (var i = 0; i < requests + 1; i++)
             {
-                RateLimiters = new List<IRateLimiter> { new RateLimiterAPIKey(1, TimeSpan.FromSeconds(1)) },
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
-                RateLimitingBehaviour = RateLimitingBehaviour.Wait,
+                Assert.That(i == requests ? triggered : !triggered);
-                LogLevel = LogLevel.Debug,
+            }
-                ApiCredentials = new ApiCredentials("TestKey", "TestSecret")
+            triggered = false;
-            });
+            await Task.Delay((int)Math.Round(perSeconds * 1000) + 10);
-            client.SetResponse("{\"property\": 123}", out _);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(!triggered);
+        }
 
+        [TestCase("/", false)]
+        [TestCase("/sapi/test", true)]
+        [TestCase("/sapi/test/123", false)]
+        public async Task EndpointRateLimiterEndpoints(string endpoint, bool expectLimited)
+        {
+            var rateLimiter = new RateLimitGate("Test");
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerEndpoint, new ExactPathFilter("/sapi/test"), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
+            
+            var requestDefinition = new RequestDefinition(endpoint, HttpMethod.Get);
 
-            // act
+            RateLimitEvent evnt = null;
-            var sw = Stopwatch.StartNew();
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
-            var result1 = client.Request<TestObject>().Result;
+            for (var i = 0; i < 2; i++)
-            client.SetKey("TestKey2", "TestSecret2"); // set to different key
+            {
-            client.SetResponse("{\"property\": 123}", out _); // reset response stream
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
-            var result2 = client.Request<TestObject>().Result;
+                bool expected = i == 1 ? (expectLimited ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
-            client.SetKey("TestKey", "TestSecret"); // set back to original key, should delay
+                Assert.That(expected);
-            client.SetResponse("{\"property\": 123}", out _); // reset response stream
+            }
-            var result3 = client.Request<TestObject>().Result;
+        }
-            sw.Stop();
 
-            // assert
+        [TestCase("/", false)]
-            Assert.IsTrue(result1.Success);
+        [TestCase("/sapi/test", true)]
-            Assert.IsTrue(result2.Success);
+        [TestCase("/sapi/test2", true)]
-            Assert.IsTrue(result3.Success);
+        [TestCase("/sapi/test23", false)]
-            Assert.IsTrue(sw.ElapsedMilliseconds > 900 && sw.ElapsedMilliseconds < 1900, $"Actual: {sw.ElapsedMilliseconds}");
+        public async Task EndpointRateLimiterMultipleEndpoints(string endpoint, bool expectLimited)
+        {
+            var rateLimiter = new RateLimitGate("Test");
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerEndpoint, new ExactPathsFilter(new[] { "/sapi/test", "/sapi/test2" }), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
+            var requestDefinition = new RequestDefinition(endpoint, HttpMethod.Get);
+
+            RateLimitEvent evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
+            for (var i = 0; i < 2; i++)
+            {
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
+                bool expected = i == 1 ? (expectLimited ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
+                Assert.That(expected);
+            }
+        }
+
+        [TestCase("123", "123", "/sapi/test", "/sapi/test", true)]
+        [TestCase("123", "456", "/sapi/test", "/sapi/test", false)]
+        [TestCase("123", "123", "/sapi/test", "/sapi/test2", true)]
+        [TestCase("123", "123", "/sapi/test2", "/sapi/test", true)]
+        [TestCase(null, "123", "/sapi/test", "/sapi/test", false)]
+        [TestCase("123", null, "/sapi/test", "/sapi/test", false)]
+        [TestCase(null, null, "/sapi/test", "/sapi/test", false)]
+        public async Task ApiKeyRateLimiterBasics(string key1, string key2, string endpoint1, string endpoint2, bool expectLimited)
+        {
+            var rateLimiter = new RateLimitGate("Test");
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerApiKey, new AuthenticatedEndpointFilter(true), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Sliding));
+            var requestDefinition1 = new RequestDefinition(endpoint1, HttpMethod.Get) { Authenticated = key1 != null };
+            var requestDefinition2 = new RequestDefinition(endpoint2, HttpMethod.Get) { Authenticated = key2 != null };
+
+            RateLimitEvent evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
+
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", key1, 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(evnt == null);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", key2, 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(expectLimited ? evnt != null : evnt == null);
+        }
+
+        [TestCase("/sapi/test", "/sapi/test", true)]
+        [TestCase("/sapi/test1", "/api/test2", true)]
+        [TestCase("/", "/sapi/test2", true)]
+        public async Task TotalRateLimiterBasics(string endpoint1, string endpoint2, bool expectLimited)
+        {
+            var rateLimiter = new RateLimitGate("Test");
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, Array.Empty<IGuardFilter>(), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
+            var requestDefinition1 = new RequestDefinition(endpoint1, HttpMethod.Get);
+            var requestDefinition2 = new RequestDefinition(endpoint2, HttpMethod.Get) { Authenticated = true };
+
+            RateLimitEvent evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
+
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(evnt == null);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", null, 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(expectLimited ? evnt != null : evnt == null);
+        }
+
+        [TestCase("https://test.com", "/sapi/test", "https://test.com", "/sapi/test", true)]
+        [TestCase("https://test2.com", "/sapi/test", "https://test.com", "/sapi/test", false)]
+        [TestCase("https://test.com", "/sapi/test", "https://test2.com", "/sapi/test", false)]
+        [TestCase("https://test.com", "/sapi/test", "https://test.com", "/sapi/test2", true)]
+        public async Task HostRateLimiterBasics(string host1, string endpoint1, string host2, string endpoint2, bool expectLimited)
+        {
+            var rateLimiter = new RateLimitGate("Test");
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, new HostFilter("https://test.com"), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
+            var requestDefinition1 = new RequestDefinition(endpoint1, HttpMethod.Get);
+            var requestDefinition2 = new RequestDefinition(endpoint2, HttpMethod.Get) { Authenticated = true };
+
+            RateLimitEvent evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
+
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, host1, "123", 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(evnt == null);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, host2, "123", 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(expectLimited ? evnt != null : evnt == null);
+        }
+
+        [TestCase("https://test.com", "https://test.com", true)]
+        [TestCase("https://test2.com", "https://test.com", false)]
+        [TestCase("https://test.com", "https://test2.com", false)]
+        public async Task ConnectionRateLimiterBasics(string host1, string host2, bool expectLimited)
+        {
+            var rateLimiter = new RateLimitGate("Test");
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, new LimitItemTypeFilter(RateLimitItemType.Connection), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
+
+            RateLimitEvent evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
+
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), host1, "123", 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(evnt == null);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), host2, "123", 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(expectLimited ? evnt != null : evnt == null);
+        }
+
+        [Test]
+        public async Task ConnectionRateLimiterCancel()
+        {
+            var rateLimiter = new RateLimitGate("Test");
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, new LimitItemTypeFilter(RateLimitItemType.Connection), 1, TimeSpan.FromSeconds(10), RateLimitWindowType.Fixed));
+
+            RateLimitEvent evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
+            var ct = new CancellationTokenSource(TimeSpan.FromSeconds(0.2));
+
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), "https://test.com", "123", 1, RateLimitingBehaviour.Wait, ct.Token);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), "https://test.com", "123", 1, RateLimitingBehaviour.Wait, ct.Token);
+            Assert.That(result2.Error, Is.TypeOf<CancellationRequestedError>());
         }
     }
 }

CryptoExchange.Net.UnitTests/SocketClientTests.cs

@@ -1,11 +1,17 @@
 using System;
+using System.Collections.Generic;
 using System.Threading;
+using System.Threading.Tasks;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.Sockets;
 using CryptoExchange.Net.UnitTests.TestImplementations;
+using CryptoExchange.Net.UnitTests.TestImplementations.Sockets;
 using Microsoft.Extensions.Logging;
-using Newtonsoft.Json.Linq;
+using Moq;
+using Newtonsoft.Json;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 
 namespace CryptoExchange.Net.UnitTests
 {
@@ -17,16 +23,15 @@ namespace CryptoExchange.Net.UnitTests
         {
             //arrange
             //act
-            var client = new TestSocketClient(new SocketClientOptions("")
+            var client = new TestSocketClient(options =>
             {
-                BaseAddress = "http://test.address.com",
+                options.SubOptions.ApiCredentials = new Authentication.ApiCredentials("1", "2");
-                ReconnectInterval = TimeSpan.FromSeconds(6)
+                options.SubOptions.MaxSocketConnections = 1;
             });
 
-
             //assert
-            Assert.IsTrue(client.BaseAddress == "http://test.address.com/");
+            ClassicAssert.NotNull(client.SubClient.ApiOptions.ApiCredentials);
-            Assert.IsTrue(client.ReconnectInterval.TotalSeconds == 6);
+            Assert.That(1 == client.SubClient.ApiOptions.MaxSocketConnections);
         }
 
         [TestCase(true)]
@@ -39,37 +44,40 @@ namespace CryptoExchange.Net.UnitTests
             socket.CanConnect = canConnect;
 
             //act
-            var connectResult = client.ConnectSocketSub(new SocketConnection(client, socket));
+            var connectResult = client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), client.SubClient, socket, null));
 
             //assert
-            Assert.IsTrue(connectResult.Success == canConnect);
+            Assert.That(connectResult.Success == canConnect);
         }
 
         [TestCase]
         public void SocketMessages_Should_BeProcessedInDataHandlers()
         {
             // arrange
-            var client = new TestSocketClient(new SocketClientOptions("") { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
+            var client = new TestSocketClient(options => {
+                options.ReconnectInterval = TimeSpan.Zero;
+            });
             var socket = client.CreateSocket();
-            socket.ShouldReconnect = true;
             socket.CanConnect = true;
-            socket.DisconnectTime = DateTime.UtcNow;
+            var sub = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
-            var sub = new SocketConnection(client, socket);
             var rstEvent = new ManualResetEvent(false);
-            JToken result = null;
+            Dictionary<string, string> result = null;
-            sub.AddSubscription(SocketSubscription.CreateForIdentifier(10, "TestHandler", true, (messageEvent) =>
+
+            client.SubClient.ConnectSocketSub(sub);
+
+            var subObj = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) =>
             {
-                result = messageEvent.JsonData;
+                result = messageEvent.Data;
                 rstEvent.Set();
-            }));
+            });
-            client.ConnectSocketSub(sub);
+            sub.AddSubscription(subObj);
 
             // act
-            socket.InvokeMessage("{\"property\": 123}");
+            socket.InvokeMessage("{\"property\": \"123\", \"action\": \"update\", \"topic\": \"topic\"}");
             rstEvent.WaitOne(1000);
 
             // assert
-            Assert.IsTrue((int)result["property"] == 123);
+            Assert.That(result["property"] == "123");
         }
 
         [TestCase(false)]
@@ -77,111 +85,147 @@ namespace CryptoExchange.Net.UnitTests
         public void SocketMessages_Should_ContainOriginalDataIfEnabled(bool enabled)
         {
             // arrange
-            var client = new TestSocketClient(new SocketClientOptions("") { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug, OutputOriginalData = enabled });
+            var client = new TestSocketClient(options =>
+            {
+                options.ReconnectInterval = TimeSpan.Zero;
+                options.SubOptions.OutputOriginalData = enabled;
+            });
             var socket = client.CreateSocket();
-            socket.ShouldReconnect = true;
             socket.CanConnect = true;
-            socket.DisconnectTime = DateTime.UtcNow;
+            var sub = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
-            var sub = new SocketConnection(client, socket);
             var rstEvent = new ManualResetEvent(false);
             string original = null;
-            sub.AddSubscription(SocketSubscription.CreateForIdentifier(10, "TestHandler", true, (messageEvent) =>
+
+            client.SubClient.ConnectSocketSub(sub);
+            var subObj = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) =>
             {
                 original = messageEvent.OriginalData;
                 rstEvent.Set();
-            }));
+            });
-            client.ConnectSocketSub(sub);
+            sub.AddSubscription(subObj);
+            var msgToSend = JsonConvert.SerializeObject(new { topic = "topic", action = "update", property = 123 });
 
             // act
-            socket.InvokeMessage("{\"property\": 123}");
+            socket.InvokeMessage(msgToSend);
             rstEvent.WaitOne(1000);
 
             // assert
-            Assert.IsTrue(original == (enabled ? "{\"property\": 123}" : null));
+            Assert.That(original == (enabled ? msgToSend : null));
-        }
-
-        [TestCase]
-        public void DisconnectedSocket_Should_Reconnect()
-        {
-            // arrange
-            bool reconnected = false;
-            var client = new TestSocketClient(new SocketClientOptions("") { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
-            var socket = client.CreateSocket();
-            socket.ShouldReconnect = true;
-            socket.CanConnect = true;
-            socket.DisconnectTime = DateTime.UtcNow;
-            var sub = new SocketConnection(client, socket);
-            sub.ShouldReconnect = true;
-            client.ConnectSocketSub(sub);
-            var rstEvent = new ManualResetEvent(false);
-            sub.ConnectionRestored += (a) =>
-            {
-                reconnected = true;
-                rstEvent.Set();
-            };
-
-            // act
-            socket.InvokeClose();
-            rstEvent.WaitOne(1000);
-
-            // assert
-            Assert.IsTrue(reconnected);
         }
 
         [TestCase()]
         public void UnsubscribingStream_Should_CloseTheSocket()
         {
             // arrange
-            var client = new TestSocketClient(new SocketClientOptions("") { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
+            var client = new TestSocketClient(options =>
+            {
+                options.ReconnectInterval = TimeSpan.Zero;
+            });
             var socket = client.CreateSocket();
             socket.CanConnect = true;
-            var sub = new SocketConnection(client, socket);
+            var sub = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
-            client.ConnectSocketSub(sub);
+            client.SubClient.ConnectSocketSub(sub);
-            var ups = new UpdateSubscription(sub, SocketSubscription.CreateForIdentifier(10, "Test", true, (e) => {}));
+
+            var subscription = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
+            var ups = new UpdateSubscription(sub, subscription);
+            sub.AddSubscription(subscription);
 
             // act
             client.UnsubscribeAsync(ups).Wait();
 
             // assert
-            Assert.IsTrue(socket.Connected == false);
+            Assert.That(socket.Connected == false);
         }
 
         [TestCase()]
         public void UnsubscribingAll_Should_CloseAllSockets()
         {
             // arrange
-            var client = new TestSocketClient(new SocketClientOptions("") { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
+            var client = new TestSocketClient(options => { options.ReconnectInterval = TimeSpan.Zero; });
             var socket1 = client.CreateSocket();
             var socket2 = client.CreateSocket();
             socket1.CanConnect = true;
             socket2.CanConnect = true;
-            var sub1 = new SocketConnection(client, socket1);
+            var sub1 = new SocketConnection(new TraceLogger(), client.SubClient, socket1, null);
-            var sub2 = new SocketConnection(client, socket2);
+            var sub2 = new SocketConnection(new TraceLogger(), client.SubClient, socket2, null);
-            client.ConnectSocketSub(sub1);
+            client.SubClient.ConnectSocketSub(sub1);
-            client.ConnectSocketSub(sub2);
+            client.SubClient.ConnectSocketSub(sub2);
+            var subscription1 = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
+            var subscription2 = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
+
+            sub1.AddSubscription(subscription1);
+            sub2.AddSubscription(subscription2);
+            var ups1 = new UpdateSubscription(sub1, subscription1);
+            var ups2 = new UpdateSubscription(sub2, subscription2);
 
             // act
             client.UnsubscribeAllAsync().Wait();
 
             // assert
-            Assert.IsTrue(socket1.Connected == false);
+            Assert.That(socket1.Connected == false);
-            Assert.IsTrue(socket2.Connected == false);
+            Assert.That(socket2.Connected == false);
         }
 
         [TestCase()]
         public void FailingToConnectSocket_Should_ReturnError()
         {
             // arrange
-            var client = new TestSocketClient(new SocketClientOptions("") { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
+            var client = new TestSocketClient(options => { options.ReconnectInterval = TimeSpan.Zero; });
             var socket = client.CreateSocket();
             socket.CanConnect = false;
-            var sub = new SocketConnection(client, socket);
+            var sub1 = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
 
             // act
-            var connectResult = client.ConnectSocketSub(sub);
+            var connectResult = client.SubClient.ConnectSocketSub(sub1);
 
             // assert
-            Assert.IsFalse(connectResult.Success);
+            ClassicAssert.IsFalse(connectResult.Success);
+        }
+
+        [TestCase()]
+        public async Task ErrorResponse_ShouldNot_ConfirmSubscription()
+        {
+            // arrange
+            var channel = "trade_btcusd";
+            var client = new TestSocketClient(opt =>
+            {
+                opt.OutputOriginalData = true;
+                opt.SocketSubscriptionsCombineTarget = 1;
+            });
+            var socket = client.CreateSocket();
+            socket.CanConnect = true;
+            client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), client.SubClient, socket, "https://test.test"));
+
+            // act
+            var sub = client.SubClient.SubscribeToSomethingAsync(channel, onUpdate => {}, ct: default);
+            socket.InvokeMessage(JsonConvert.SerializeObject(new { channel, action = "subscribe", status = "error" }));
+            await sub;
+
+            // assert
+            ClassicAssert.IsFalse(client.SubClient.TestSubscription.Confirmed);
+        }
+
+        [TestCase()]
+        public async Task SuccessResponse_Should_ConfirmSubscription()
+        {
+            // arrange
+            var channel = "trade_btcusd";
+            var client = new TestSocketClient(opt =>
+            {
+                opt.OutputOriginalData = true;
+                opt.SocketSubscriptionsCombineTarget = 1;
+            });
+            var socket = client.CreateSocket();
+            socket.CanConnect = true;
+            client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), client.SubClient, socket, "https://test.test"));
+
+            // act
+            var sub = client.SubClient.SubscribeToSomethingAsync(channel, onUpdate => {}, ct: default);
+            socket.InvokeMessage(JsonConvert.SerializeObject(new { channel, action = "subscribe", status = "confirmed" }));
+            await sub;
+
+            // assert
+            Assert.That(client.SubClient.TestSubscription.Confirmed);
         }
     }
 }

CryptoExchange.Net.UnitTests/SymbolOrderBookTests.cs

@@ -1,33 +1,36 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.OrderBook;
-using CryptoExchange.Net.Sockets;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 
 namespace CryptoExchange.Net.UnitTests
 {
     [TestFixture]
     public class SymbolOrderBookTests
     {
-        private static OrderBookOptions defaultOrderBookOptions = new OrderBookOptions("Test", true, false);
+        private static readonly OrderBookOptions _defaultOrderBookOptions = new OrderBookOptions();
 
         private class TestableSymbolOrderBook : SymbolOrderBook
         {
-            public TestableSymbolOrderBook() : base("BTC/USD", defaultOrderBookOptions)
+            public TestableSymbolOrderBook() : base(null, "Test", "Test", "BTC/USD")
             {
+                Initialize(_defaultOrderBookOptions);
             }
 
-            public override void Dispose() {}
 
-            protected override Task<CallResult<bool>> DoResyncAsync()
+            protected override Task<CallResult<bool>> DoResyncAsync(CancellationToken ct)
             {
                 throw new NotImplementedException();
             }
 
-            protected override Task<CallResult<UpdateSubscription>> DoStartAsync()
+            protected override Task<CallResult<UpdateSubscription>> DoStartAsync(CancellationToken ct)
             {
                 throw new NotImplementedException();
             }
@@ -35,12 +38,12 @@ namespace CryptoExchange.Net.UnitTests
             public void SetData(IEnumerable<ISymbolOrderBookEntry> bids, IEnumerable<ISymbolOrderBookEntry> asks)
             {
                 Status = OrderBookStatus.Synced;
-                base.bids.Clear();
+                base._bids.Clear();
                 foreach (var bid in bids)
-                    base.bids.Add(bid.Price, bid);
+                    base._bids.Add(bid.Price, bid);
-                base.asks.Clear();
+                base._asks.Clear();
                 foreach (var ask in asks)
-                    base.asks.Add(ask.Price, ask);
+                    base._asks.Add(ask.Price, ask);
             }
         }
 
@@ -54,31 +57,31 @@ namespace CryptoExchange.Net.UnitTests
         public void GivenEmptyBidList_WhenBestBid_ThenEmptySymbolOrderBookEntry()
         {
             var symbolOrderBook = new TestableSymbolOrderBook();
-            Assert.IsNotNull(symbolOrderBook.BestBid);
+            ClassicAssert.IsNotNull(symbolOrderBook.BestBid);
-            Assert.AreEqual(0m, symbolOrderBook.BestBid.Price);
+            Assert.That(0m == symbolOrderBook.BestBid.Price);
-            Assert.AreEqual(0m, symbolOrderBook.BestAsk.Quantity);
+            Assert.That(0m == symbolOrderBook.BestAsk.Quantity);
         }
 
         [TestCase]
         public void GivenEmptyAskList_WhenBestAsk_ThenEmptySymbolOrderBookEntry()
         {
             var symbolOrderBook = new TestableSymbolOrderBook();
-            Assert.IsNotNull(symbolOrderBook.BestBid);
+            ClassicAssert.IsNotNull(symbolOrderBook.BestBid);
-            Assert.AreEqual(0m, symbolOrderBook.BestBid.Price);
+            Assert.That(0m == symbolOrderBook.BestBid.Price);
-            Assert.AreEqual(0m, symbolOrderBook.BestAsk.Quantity);
+            Assert.That(0m == symbolOrderBook.BestAsk.Quantity);
         }
 
         [TestCase]
         public void GivenEmptyBidAndAskList_WhenBestOffers_ThenEmptySymbolOrderBookEntries()
         {
             var symbolOrderBook = new TestableSymbolOrderBook();
-            Assert.IsNotNull(symbolOrderBook.BestOffers);
+            ClassicAssert.IsNotNull(symbolOrderBook.BestOffers);
-            Assert.IsNotNull(symbolOrderBook.BestOffers.Bid);
+            ClassicAssert.IsNotNull(symbolOrderBook.BestOffers.Bid);
-            Assert.IsNotNull(symbolOrderBook.BestOffers.Ask);
+            ClassicAssert.IsNotNull(symbolOrderBook.BestOffers.Ask);
-            Assert.AreEqual(0m, symbolOrderBook.BestOffers.Bid.Price);
+            Assert.That(0m == symbolOrderBook.BestOffers.Bid.Price);
-            Assert.AreEqual(0m, symbolOrderBook.BestOffers.Bid.Quantity);
+            Assert.That(0m == symbolOrderBook.BestOffers.Bid.Quantity);
-            Assert.AreEqual(0m, symbolOrderBook.BestOffers.Ask.Price);
+            Assert.That(0m == symbolOrderBook.BestOffers.Ask.Price);
-            Assert.AreEqual(0m, symbolOrderBook.BestOffers.Ask.Quantity);
+            Assert.That(0m == symbolOrderBook.BestOffers.Ask.Quantity);
         }
 
         [TestCase]
@@ -101,12 +104,40 @@ namespace CryptoExchange.Net.UnitTests
             var resultBids2 = orderbook.CalculateAverageFillPrice(1.5m, OrderBookEntryType.Bid);
             var resultAsks2 = orderbook.CalculateAverageFillPrice(1.5m, OrderBookEntryType.Ask);
 
-            Assert.True(resultBids.Success);
+            Assert.That(resultBids.Success);
-            Assert.True(resultAsks.Success);
+            Assert.That(resultAsks.Success);
-            Assert.AreEqual(1.05m, resultBids.Data);
+            Assert.That(1.05m == resultBids.Data);
-            Assert.AreEqual(1.25m, resultAsks.Data);
+            Assert.That(1.25m == resultAsks.Data);
-            Assert.AreEqual(1.06666667m, resultBids2.Data);
+            Assert.That(1.06666667m == resultBids2.Data);
-            Assert.AreEqual(1.23333333m, resultAsks2.Data);
+            Assert.That(1.23333333m == resultAsks2.Data);
+        }
+
+        [TestCase]
+        public void CalculateTradableAmount()
+        {
+            var orderbook = new TestableSymbolOrderBook();
+            orderbook.SetData(new List<ISymbolOrderBookEntry>
+            {
+                new BookEntry{ Price = 1, Quantity = 1 },
+                new BookEntry{ Price = 1.1m, Quantity = 1 },
+            },
+            new List<ISymbolOrderBookEntry>()
+            {
+                new BookEntry{ Price = 1.2m, Quantity = 1 },
+                new BookEntry{ Price = 1.3m, Quantity = 1 },
+            });
+
+            var resultBids = orderbook.CalculateTradableAmount(2, OrderBookEntryType.Bid);
+            var resultAsks = orderbook.CalculateTradableAmount(2, OrderBookEntryType.Ask);
+            var resultBids2 = orderbook.CalculateTradableAmount(1.5m, OrderBookEntryType.Bid);
+            var resultAsks2 = orderbook.CalculateTradableAmount(1.5m, OrderBookEntryType.Ask);
+
+            Assert.That(resultBids.Success);
+            Assert.That(resultAsks.Success);
+            Assert.That(1.9m == resultBids.Data);
+            Assert.That(1.61538462m == resultAsks.Data);
+            Assert.That(1.4m == resultBids2.Data);
+            Assert.That(1.23076923m == resultAsks2.Data);
         }
     }
 }

CryptoExchange.Net.UnitTests/SystemTextJsonConverterTests.cs

@@ -0,0 +1,362 @@
+using CryptoExchange.Net.Attributes;
+using CryptoExchange.Net.Converters.SystemTextJson;
+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;
+
+namespace CryptoExchange.Net.UnitTests
+{
+    [TestFixture()]
+    public class SystemTextJsonConverterTests
+    {
+        [TestCase("2021-05-12")]
+        [TestCase("20210512")]
+        [TestCase("210512")]
+        [TestCase("1620777600.000")]
+        [TestCase("1620777600000")]
+        [TestCase("2021-05-12T00:00:00.000Z")]
+        [TestCase("2021-05-12T00:00:00.000000000Z")]
+        [TestCase("0.000000", true)]
+        [TestCase("0", true)]
+        [TestCase("", true)]
+        [TestCase("  ", true)]
+        public void TestDateTimeConverterString(string input, bool expectNull = false)
+        {
+            var output = JsonSerializer.Deserialize<STJTimeObject>($"{{ \"time\": \"{input}\" }}");
+            Assert.That(output.Time == (expectNull ? null: new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc)));
+        }
+
+        [TestCase(1620777600.000)]
+        [TestCase(1620777600000d)]
+        public void TestDateTimeConverterDouble(double input)
+        {
+            var output = JsonSerializer.Deserialize<STJTimeObject>($"{{ \"time\": {input} }}");
+            Assert.That(output.Time == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [TestCase(1620777600)]
+        [TestCase(1620777600000)]
+        [TestCase(1620777600000000)]
+        [TestCase(1620777600000000000)]
+        [TestCase(0, true)]
+        public void TestDateTimeConverterLong(long input, bool expectNull = false)
+        {
+            var output = JsonSerializer.Deserialize<STJTimeObject>($"{{ \"time\": {input} }}");
+            Assert.That(output.Time == (expectNull ? null : new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc)));
+        }
+
+        [TestCase(1620777600)]
+        [TestCase(1620777600.000)]
+        public void TestDateTimeConverterFromSeconds(double input)
+        {
+            var output = DateTimeConverter.ConvertFromSeconds(input);
+            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToSeconds()
+        {
+            var output = DateTimeConverter.ConvertToSeconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(output == 1620777600);
+        }
+
+        [TestCase(1620777600000)]
+        [TestCase(1620777600000.000)]
+        public void TestDateTimeConverterFromMilliseconds(double input)
+        {
+            var output = DateTimeConverter.ConvertFromMilliseconds(input);
+            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToMilliseconds()
+        {
+            var output = DateTimeConverter.ConvertToMilliseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(output == 1620777600000);
+        }
+
+        [TestCase(1620777600000000)]
+        public void TestDateTimeConverterFromMicroseconds(long input)
+        {
+            var output = DateTimeConverter.ConvertFromMicroseconds(input);
+            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToMicroseconds()
+        {
+            var output = DateTimeConverter.ConvertToMicroseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(output == 1620777600000000);
+        }
+
+        [TestCase(1620777600000000000)]
+        public void TestDateTimeConverterFromNanoseconds(long input)
+        {
+            var output = DateTimeConverter.ConvertFromNanoseconds(input);
+            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToNanoseconds()
+        {
+            var output = DateTimeConverter.ConvertToNanoseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(output == 1620777600000000000);
+        }
+
+        [TestCase()]
+        public void TestDateTimeConverterNull()
+        {
+            var output = JsonSerializer.Deserialize<STJTimeObject>($"{{ \"time\": null }}");
+            Assert.That(output.Time == null);
+        }
+
+        [TestCase(TestEnum.One, "1")]
+        [TestCase(TestEnum.Two, "2")]
+        [TestCase(TestEnum.Three, "three")]
+        [TestCase(TestEnum.Four, "Four")]
+        [TestCase(null, null)]
+        public void TestEnumConverterNullableGetStringTests(TestEnum? value, string expected)
+        {
+            var output = EnumConverter.GetString(value);
+            Assert.That(output == expected);
+        }
+
+        [TestCase(TestEnum.One, "1")]
+        [TestCase(TestEnum.Two, "2")]
+        [TestCase(TestEnum.Three, "three")]
+        [TestCase(TestEnum.Four, "Four")]
+        public void TestEnumConverterGetStringTests(TestEnum value, string expected)
+        {
+            var output = EnumConverter.GetString(value);
+            Assert.That(output == expected);
+        }
+
+        [TestCase("1", TestEnum.One)]
+        [TestCase("2", TestEnum.Two)]
+        [TestCase("3", TestEnum.Three)]
+        [TestCase("three", TestEnum.Three)]
+        [TestCase("Four", TestEnum.Four)]
+        [TestCase("four", TestEnum.Four)]
+        [TestCase("Four1", null)]
+        [TestCase(null, null)]
+        public void TestEnumConverterNullableDeserializeTests(string value, TestEnum? expected)
+        {
+            var val = value == null ? "null" : $"\"{value}\"";
+            var output = JsonSerializer.Deserialize<STJEnumObject>($"{{ \"Value\": {val} }}");
+            Assert.That(output.Value == expected);
+        }
+
+        [TestCase("1", TestEnum.One)]
+        [TestCase("2", TestEnum.Two)]
+        [TestCase("3", TestEnum.Three)]
+        [TestCase("three", TestEnum.Three)]
+        [TestCase("Four", TestEnum.Four)]
+        [TestCase("four", TestEnum.Four)]
+        [TestCase("Four1", TestEnum.One)]
+        [TestCase(null, TestEnum.One)]
+        public void TestEnumConverterNotNullableDeserializeTests(string value, TestEnum? expected)
+        {
+            var val = value == null ? "null" : $"\"{value}\"";
+            var output = JsonSerializer.Deserialize<NotNullableSTJEnumObject>($"{{ \"Value\": {val} }}");
+            Assert.That(output.Value == expected);
+        }
+
+        [TestCase("1", TestEnum.One)]
+        [TestCase("2", TestEnum.Two)]
+        [TestCase("3", TestEnum.Three)]
+        [TestCase("three", TestEnum.Three)]
+        [TestCase("Four", TestEnum.Four)]
+        [TestCase("four", TestEnum.Four)]
+        [TestCase("Four1", TestEnum.One)]
+        [TestCase(null, TestEnum.One)]
+        public void TestEnumConverterParseStringTests(string value, TestEnum? expected)
+        {
+            var result = EnumConverter.ParseString<TestEnum>(value);
+            Assert.That(result == expected);
+        }
+
+        [TestCase("1", true)]
+        [TestCase("true", true)]
+        [TestCase("yes", true)]
+        [TestCase("y", true)]
+        [TestCase("on", true)]
+        [TestCase("-1", false)]
+        [TestCase("0", false)]
+        [TestCase("n", false)]
+        [TestCase("no", false)]
+        [TestCase("false", false)]
+        [TestCase("off", false)]
+        [TestCase("", null)]
+        public void TestBoolConverter(string value, bool? expected)
+        {
+            var val = value == null ? "null" : $"\"{value}\"";
+            var output = JsonSerializer.Deserialize<STJBoolObject>($"{{ \"Value\": {val} }}");
+            Assert.That(output.Value == expected);
+        }
+
+        [TestCase("1", true)]
+        [TestCase("true", true)]
+        [TestCase("yes", true)]
+        [TestCase("y", true)]
+        [TestCase("on", true)]
+        [TestCase("-1", false)]
+        [TestCase("0", false)]
+        [TestCase("n", false)]
+        [TestCase("no", false)]
+        [TestCase("false", false)]
+        [TestCase("off", false)]
+        [TestCase("", false)]
+        public void TestBoolConverterNotNullable(string value, bool expected)
+        {
+            var val = value == null ? "null" : $"\"{value}\"";
+            var output = JsonSerializer.Deserialize<NotNullableSTJBoolObject>($"{{ \"Value\": {val} }}");
+            Assert.That(output.Value == expected);
+        }
+
+        [TestCase("1", 1)]
+        [TestCase("1.1", 1.1)]
+        [TestCase("-1.1", -1.1)]
+        [TestCase(null, null)]
+        [TestCase("", null)]
+        [TestCase("null", null)]
+        [TestCase("1E+2", 100)]
+        [TestCase("1E-2", 0.01)]
+        [TestCase("80228162514264337593543950335", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
+        public void TestDecimalConverterString(string value, decimal? expected)
+        {
+            var result = JsonSerializer.Deserialize<STJDecimalObject>("{ \"test\": \""+ value + "\"}");
+            Assert.That(result.Test, Is.EqualTo(expected == -999 ? decimal.MaxValue : expected));
+        }
+
+        [TestCase("1", 1)]
+        [TestCase("1.1", 1.1)]
+        [TestCase("-1.1", -1.1)]
+        [TestCase("null", null)]
+        [TestCase("1E+2", 100)]
+        [TestCase("1E-2", 0.01)]
+        [TestCase("80228162514264337593543950335", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
+        public void TestDecimalConverterNumber(string value, decimal? expected)
+        {
+            var result = JsonSerializer.Deserialize<STJDecimalObject>("{ \"test\": " + value + "}");
+            Assert.That(result.Test, Is.EqualTo(expected == -999 ? decimal.MaxValue : expected));
+        }
+
+        [Test()]
+        public void TestArrayConverter()
+        {
+            var data = new Test()
+            {
+                Prop1 = 2,
+                Prop2 = null,
+                Prop3 = "123",
+                Prop3Again = "123",
+                Prop4 = null,
+                Prop5 = new Test2
+                {
+                    Prop21 = 3,
+                    Prop22 = "456"
+                },
+                Prop6 = new Test3
+                {
+                    Prop31 = 4,
+                    Prop32 = "789"
+                },
+                Prop7 = TestEnum.Two
+            };
+
+            var serialized = JsonSerializer.Serialize(data);
+            var deserialized = JsonSerializer.Deserialize<Test>(serialized);
+
+            Assert.That(deserialized.Prop1, Is.EqualTo(2));
+            Assert.That(deserialized.Prop2, Is.Null);
+            Assert.That(deserialized.Prop3, Is.EqualTo("123"));
+            Assert.That(deserialized.Prop3Again, Is.EqualTo("123"));
+            Assert.That(deserialized.Prop4, Is.Null);
+            Assert.That(deserialized.Prop5.Prop21, Is.EqualTo(3));
+            Assert.That(deserialized.Prop5.Prop22, Is.EqualTo("456"));
+            Assert.That(deserialized.Prop6.Prop31, Is.EqualTo(4));
+            Assert.That(deserialized.Prop6.Prop32, Is.EqualTo("789"));
+            Assert.That(deserialized.Prop7, Is.EqualTo(TestEnum.Two));
+        }
+    }
+
+    public class STJDecimalObject
+    {
+        [JsonConverter(typeof(DecimalConverter))]
+        [JsonPropertyName("test")]
+        public decimal? Test { get; set; }
+    }
+
+    public class STJTimeObject
+    {
+        [JsonConverter(typeof(DateTimeConverter))]
+        [JsonPropertyName("time")]
+        public DateTime? Time { get; set; }
+    }
+
+    public class STJEnumObject
+    {
+        [JsonConverter(typeof(EnumConverter))]
+        public TestEnum? Value { get; set; }
+    }
+
+    public class NotNullableSTJEnumObject
+    {
+        [JsonConverter(typeof(EnumConverter))]
+        public TestEnum Value { get; set; }
+    }
+
+    public class STJBoolObject
+    {
+        [JsonConverter(typeof(BoolConverter))]
+        public bool? Value { get; set; }
+    }
+
+    public class NotNullableSTJBoolObject
+    {
+        [JsonConverter(typeof(BoolConverter))]
+        public bool Value { get; set; }
+    }
+
+    [JsonConverter(typeof(ArrayConverter))]
+    record Test
+    {
+        [ArrayProperty(0)]
+        public int Prop1 { get; set; }
+        [ArrayProperty(1)]
+        public int? Prop2 { get; set; }
+        [ArrayProperty(2)]
+        public string Prop3 { get; set; }
+        [ArrayProperty(2)]
+        public string Prop3Again { get; set; }
+        [ArrayProperty(3)]
+        public string Prop4 { get; set; }
+        [ArrayProperty(4)]
+        public Test2 Prop5 { get; set; }
+        [ArrayProperty(5)]
+        public Test3 Prop6 { get; set; }
+        [ArrayProperty(6), JsonConverter(typeof(EnumConverter))]
+        public TestEnum? Prop7 { get; set; }
+    }
+
+    [JsonConverter(typeof(ArrayConverter))]
+    record Test2
+    {
+        [ArrayProperty(0)]
+        public int Prop21 { get; set; }
+        [ArrayProperty(1)]
+        public string Prop22 { get; set; }
+    }
+
+    record Test3
+    {
+        [JsonPropertyName("prop31")]
+        public int Prop31 { get; set; }
+        [JsonPropertyName("prop32")]
+        public string Prop32 { get; set; }
+    }
+}

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

@@ -0,0 +1,52 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Sockets;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
+{
+    internal class SubResponse
+    {
+
+        [JsonProperty("action")]
+        public string Action { get; set; } = null!;
+
+        [JsonProperty("channel")]
+        public string Channel { get; set; } = null!;
+
+        [JsonProperty("status")]
+        public string Status { get; set; } = null!;
+    }
+
+    internal class UnsubResponse
+    {
+        [JsonProperty("action")]
+        public string Action { get; set; } = null!;
+
+        [JsonProperty("status")]
+        public string Status { get; set; } = null!;
+    }
+
+    internal class TestChannelQuery : Query<SubResponse>
+    {
+        public override HashSet<string> ListenerIdentifiers { get; set; }
+
+        public TestChannelQuery(string channel, string request, bool authenticated, int weight = 1) : base(request, authenticated, weight)
+        {
+            ListenerIdentifiers = new HashSet<string> { request + "-" + channel };
+        }
+
+        public override CallResult<SubResponse> HandleMessage(SocketConnection connection, DataEvent<SubResponse> message)
+        {
+            if (!message.Data.Status.Equals("confirmed", StringComparison.OrdinalIgnoreCase))
+            {
+                return new CallResult<SubResponse>(new ServerError(message.Data.Status));
+            }
+
+            return base.HandleMessage(connection, message);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,36 @@
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Sockets;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
+{
+    internal class TestSubscription<T> : Subscription<object, object>
+    {
+        private readonly Action<DataEvent<T>> _handler;
+
+        public override HashSet<string> ListenerIdentifiers { get; set; } = new HashSet<string> { "update-topic" };
+
+        public TestSubscription(ILogger logger, Action<DataEvent<T>> handler) : base(logger, false)
+        {
+            _handler = handler;
+        }
+
+        public override CallResult DoHandleMessage(SocketConnection connection, DataEvent<object> message)
+        {
+            var data = (T)message.Data;
+            _handler.Invoke(message.As(data));
+            return new CallResult(null);
+        }
+
+        public override Type GetMessageType(IMessageAccessor message) => typeof(T);
+        public override Query GetSubQuery(SocketConnection connection) => new TestQuery("sub", new object(), false, 1);
+        public override Query GetUnsubQuery() => new TestQuery("unsub", new object(), false, 1);
+    }
+}

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

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

CryptoExchange.Net.UnitTests/TestImplementations/TestBaseClient.cs

@@ -1,35 +1,66 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.IO;
 using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
 using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Clients;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.SharedApis;
+using CryptoExchange.Net.UnitTests.TestImplementations;
 using Microsoft.Extensions.Logging;
 
 namespace CryptoExchange.Net.UnitTests
 {
     public class TestBaseClient: BaseClient
     {       
-        public TestBaseClient(): base("Test", new RestClientOptions("http://testurl.url"), null)
+        public TestSubClient SubClient { get; }
+
+        public TestBaseClient(): base(null, "Test")
         {
+            var options = new TestClientOptions();
+            Initialize(options);
+            SubClient = AddApiClient(new TestSubClient(options, new RestApiOptions()));
         }
 
-        public TestBaseClient(RestClientOptions exchangeOptions) : base("Test", exchangeOptions, exchangeOptions.ApiCredentials == null ? null : new TestAuthProvider(exchangeOptions.ApiCredentials))
+        public TestBaseClient(TestClientOptions exchangeOptions) : base(null, "Test")
         {
+            Initialize(exchangeOptions);
+            SubClient = AddApiClient(new TestSubClient(exchangeOptions, new RestApiOptions()));
         }
 
         public void Log(LogLevel verbosity, string data)
         {
-            log.Write(verbosity, data);
+            _logger.Log(verbosity, data);
+        }
+    }
+
+    public class TestSubClient : RestApiClient
+    {
+        public TestSubClient(RestExchangeOptions<TestEnvironment> options, RestApiOptions apiOptions) : base(new TraceLogger(), null, "https://localhost:123", options, apiOptions)
+        {
         }
 
         public CallResult<T> Deserialize<T>(string data)
         {
-            return Deserialize<T>(data, false);
+            var stream = new MemoryStream(Encoding.UTF8.GetBytes(data));
+            var accessor = CreateAccessor();
+            var valid = accessor.Read(stream, true).Result;
+            if (!valid)
+                return new CallResult<T>(new ServerError(data));
+            
+            var deserializeResult = accessor.Deserialize<T>();
+            return deserializeResult;
         }
 
-        public string FillParameters(string path, params string[] values)
+        /// <inheritdoc />
-        {
+        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode futuresType, DateTime? deliverDate = null) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
-            return FillPathParameter(path, values);
+        public override TimeSpan? GetTimeOffset() => null;
-        }
+        public override TimeSyncInfo GetTimeSyncInfo() => null;
+        protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials) => throw new NotImplementedException();
+        protected override Task<WebCallResult<DateTime>> GetServerTimestampAsync() => throw new NotImplementedException();
     }
 
     public class TestAuthProvider : AuthenticationProvider
@@ -38,19 +69,11 @@ namespace CryptoExchange.Net.UnitTests
         {
         }
 
-        public override Dictionary<string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary<string, object> parameters, bool signed, HttpMethodParameterPosition postParameters, ArrayParametersSerialization arraySerialization)
+        public override void AuthenticateRequest(RestApiClient apiClient, Uri uri, HttpMethod method, ref IDictionary<string, object> uriParams, ref IDictionary<string, object> bodyParams, ref Dictionary<string, string> headers, bool auth, ArrayParametersSerialization arraySerialization, HttpMethodParameterPosition parameterPosition, RequestBodyFormat bodyFormat)
         {
-            return base.AddAuthenticationToHeaders(uri, method, parameters, signed, postParameters, arraySerialization);
         }
 
-        public override Dictionary<string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary<string, object> parameters, bool signed, HttpMethodParameterPosition postParameters, ArrayParametersSerialization arraySerialization)
+        public string GetKey() => _credentials.Key;
-        {
+        public string GetSecret() => _credentials.Secret;
-            return base.AddAuthenticationToParameters(uri, method, parameters, signed, postParameters, arraySerialization);
-        }
-
-        public override string Sign(string toSign)
-        {
-            return toSign;
-        }
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/TestRestClient.cs

@@ -12,29 +12,30 @@ using System.Threading;
 using System.Threading.Tasks;
 using CryptoExchange.Net.Authentication;
 using System.Collections.Generic;
+using CryptoExchange.Net.Objects.Options;
+using Microsoft.Extensions.Logging;
+using CryptoExchange.Net.Clients;
+using CryptoExchange.Net.SharedApis;
+using Microsoft.Extensions.Options;
 
 namespace CryptoExchange.Net.UnitTests.TestImplementations
 {
-    public class TestRestClient: RestClient
+    public class TestRestClient: BaseRestClient
     {
-        public TestRestClient() : base("Test", new RestClientOptions("http://testurl.url"), null)
+        public TestRestApi1Client Api1 { get; }
+        public TestRestApi2Client Api2 { get; }
+
+        public TestRestClient(Action<TestClientOptions> optionsDelegate = null)
+            : this(null, null, Options.Create(ApplyOptionsDelegate(optionsDelegate)))
         {
-            RequestFactory = new Mock<IRequestFactory>().Object;
         }
 
-        public TestRestClient(RestClientOptions exchangeOptions) : base("Test", exchangeOptions, exchangeOptions.ApiCredentials == null ? null : new TestAuthProvider(exchangeOptions.ApiCredentials))
+        public TestRestClient(HttpClient httpClient, ILoggerFactory loggerFactory, IOptions<TestClientOptions> options) : base(loggerFactory, "Test")
         {
-            RequestFactory = new Mock<IRequestFactory>().Object;
+            Initialize(options.Value);
-        }
 
-        public void SetParameterPosition(HttpMethod method, HttpMethodParameterPosition position)
+            Api1 = new TestRestApi1Client(options.Value);
-        {
+            Api2 = new TestRestApi2Client(options.Value);
-            ParameterPositions[method] = position;
-        }
-
-        public void SetKey(string key, string secret)
-        {
-            SetAuthenticationProvider(new UnitTests.TestAuthProvider(new ApiCredentials(key, secret)));
         }
 
         public void SetResponse(string responseData, out IRequest requestObj)
@@ -56,14 +57,23 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             request.Setup(c => c.AddHeader(It.IsAny<string>(), It.IsAny<string>())).Callback<string, string>((key, val) => headers.Add(key, new List<string> { val }));
             request.Setup(c => c.GetHeaders()).Returns(() => headers);
 
-            var factory = Mock.Get(RequestFactory);
+            var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<string>(), It.IsAny<int>()))
+            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<HttpMethod, string, int>((method, uri, id) => 
+                .Callback<HttpMethod, Uri, int>((method, uri, id) => 
                 { 
-                    request.Setup(a => a.Uri).Returns(new Uri(uri));
+                    request.Setup(a => a.Uri).Returns(uri);
                     request.Setup(a => a.Method).Returns(method); 
                 })
                 .Returns(request.Object);
+
+            factory = Mock.Get(Api2.RequestFactory);
+            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+                .Callback<HttpMethod, Uri, int>((method, uri, id) =>
+                {
+                    request.Setup(a => a.Uri).Returns(uri);
+                    request.Setup(a => a.Method).Returns(method);
+                })
+                .Returns(request.Object);
             requestObj = request.Object;
         }
 
@@ -73,10 +83,17 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             typeof(HttpRequestException).GetField("_message", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(we, message);
            
             var request = new Mock<IRequest>();
+            request.Setup(c => c.Uri).Returns(new Uri("http://www.test.com"));
+            request.Setup(c => c.GetHeaders()).Returns(new Dictionary<string, IEnumerable<string>>());
             request.Setup(c => c.GetResponseAsync(It.IsAny<CancellationToken>())).Throws(we);
 
-            var factory = Mock.Get(RequestFactory);
+            var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<string>(), It.IsAny<int>()))
+            factory.Setup(c => c.Create(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>()))
                 .Returns(request.Object);
         }
 
@@ -98,38 +115,112 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             request.Setup(c => c.AddHeader(It.IsAny<string>(), It.IsAny<string>())).Callback<string, string>((key, val) => headers.Add(key, new List<string> { val }));
             request.Setup(c => c.GetHeaders()).Returns(headers);
 
-            var factory = Mock.Get(RequestFactory);
+            var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<string>(), It.IsAny<int>()))
+            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<HttpMethod, string, int>((method, uri, id) => request.Setup(a => a.Uri).Returns(new Uri(uri)))
+                .Callback<HttpMethod, Uri, int>((method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
+                .Returns(request.Object);
+
+            factory = Mock.Get(Api2.RequestFactory);
+            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+                .Callback<HttpMethod, Uri, int>((method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
                 .Returns(request.Object);
         }
+    }
 
-        public async Task<CallResult<T>> Request<T>(CancellationToken ct = default) where T:class
+    public class TestRestApi1Client : RestApiClient
+    {
+        public TestRestApi1Client(TestClientOptions options) : base(new TraceLogger(), null, "https://localhost:123", options, options.Api1Options)
         {
-            return await SendRequestAsync<T>(new Uri("http://www.test.com"), HttpMethod.Get, ct);
+            RequestFactory = new Mock<IRequestFactory>().Object;
+        }
+
+        /// <inheritdoc />
+        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode futuresType, DateTime? deliverDate = null) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
+
+        public async Task<CallResult<T>> Request<T>(CancellationToken ct = default) where T : class
+        {
+            return await SendRequestAsync<T>(new Uri("http://www.test.com"), HttpMethod.Get, ct, requestWeight: 0);
         }
 
         public async Task<CallResult<T>> RequestWithParams<T>(HttpMethod method, Dictionary<string, object> parameters, Dictionary<string, string> headers) where T : class
         {
-            return await SendRequestAsync<T>(new Uri("http://www.test.com"), method, default, parameters, additionalHeaders: headers);
+            return await SendRequestAsync<T>(new Uri("http://www.test.com"), method, default, parameters, requestWeight: 0, additionalHeaders: headers);
+        }
+
+        public void SetParameterPosition(HttpMethod method, HttpMethodParameterPosition position)
+        {
+            ParameterPositions[method] = position;
+        }
+
+        public override TimeSpan? GetTimeOffset()
+        {
+            throw new NotImplementedException();
+        }
+
+        protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials)
+            => new TestAuthProvider(credentials);
+
+        protected override Task<WebCallResult<DateTime>> GetServerTimestampAsync()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override TimeSyncInfo GetTimeSyncInfo()
+        {
+            throw new NotImplementedException();
         }
     }
 
-    public class TestAuthProvider : AuthenticationProvider
+    public class TestRestApi2Client : RestApiClient
     {
-        public TestAuthProvider(ApiCredentials credentials) : base(credentials)
+        public TestRestApi2Client(TestClientOptions options) : base(new TraceLogger(), null, "https://localhost:123", options, options.Api2Options)
         {
+            RequestFactory = new Mock<IRequestFactory>().Object;
         }
+
+        /// <inheritdoc />
+        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode futuresType, DateTime? deliverDate = null) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
+
+        public async Task<CallResult<T>> Request<T>(CancellationToken ct = default) where T : class
+        {
+            return await SendRequestAsync<T>(new Uri("http://www.test.com"), HttpMethod.Get, ct, requestWeight: 0);
+        }
+
+        protected override Error ParseErrorResponse(int httpStatusCode, IEnumerable<KeyValuePair<string, IEnumerable<string>>> responseHeaders, IMessageAccessor accessor)
+        {
+            var errorData = accessor.Deserialize<TestError>();
+
+            return new ServerError(errorData.Data.ErrorCode, errorData.Data.ErrorMessage);
+        }
+
+        public override TimeSpan? GetTimeOffset()
+        {
+            throw new NotImplementedException();
+        }
+
+        protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials)
+            => new TestAuthProvider(credentials);
+
+        protected override Task<WebCallResult<DateTime>> GetServerTimestampAsync()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override TimeSyncInfo GetTimeSyncInfo()
+        {
+            throw new NotImplementedException();
+        }
+    }
+
+    public class TestError
+    {
+        public int ErrorCode { get; set; }
+        public string ErrorMessage { get; set; }
     }
 
     public class ParseErrorTestRestClient: TestRestClient
     {
         public ParseErrorTestRestClient() { }
-        public ParseErrorTestRestClient(RestClientOptions exchangeOptions) : base(exchangeOptions) { }
 
-        protected override Error ParseErrorResponse(JToken error)
-        {
-            return new ServerError((int)error["errorCode"], (string)error["errorMessage"]);
-        }
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/TestSocket.cs

@@ -1,115 +1,132 @@
-using System;
+//using System;
-using System.Security.Authentication;
+//using System.IO;
-using System.Text;
+//using System.Net.WebSockets;
-using System.Threading.Tasks;
+//using System.Security.Authentication;
-using CryptoExchange.Net.Interfaces;
+//using System.Text;
-using CryptoExchange.Net.Objects;
+//using System.Threading.Tasks;
+//using CryptoExchange.Net.Interfaces;
+//using CryptoExchange.Net.Objects;
 
-namespace CryptoExchange.Net.UnitTests.TestImplementations
+//namespace CryptoExchange.Net.UnitTests.TestImplementations
-{
+//{
-    public class TestSocket: IWebsocket
+//    public class TestSocket: IWebsocket
-    {
+//    {
-        public bool CanConnect { get; set; }
+//        public bool CanConnect { get; set; }
-        public bool Connected { get; set; }
+//        public bool Connected { get; set; }
 
-        public event Action OnClose;
+//        public event Func<Task> OnClose;
-        public event Action<string> OnMessage;
+//#pragma warning disable 0067
-        public event Action<Exception> OnError;
+//        public event Func<Task> OnReconnected;
-        public event Action OnOpen;
+//        public event Func<Task> OnReconnecting;
+//        public event Func<int, Task> OnRequestRateLimited;
+//#pragma warning restore 0067
+//        public event Func<int, Task> OnRequestSent;
+//        public event Func<WebSocketMessageType, ReadOnlyMemory<byte>, Task> OnStreamMessage;
+//        public event Func<Exception, Task> OnError;
+//        public event Func<Task> OnOpen;
+//        public Func<Task<Uri>> GetReconnectionUrl { get; set; }
 
-        public int Id { get; }
+//        public int Id { get; }
-        public bool ShouldReconnect { get; set; }
+//        public bool ShouldReconnect { get; set; }
-        public TimeSpan Timeout { get; set; }
+//        public TimeSpan Timeout { get; set; }
-        public Func<string, string> DataInterpreterString { get; set; }
+//        public Func<string, string> DataInterpreterString { get; set; }
-        public Func<byte[], string> DataInterpreterBytes { get; set; }
+//        public Func<byte[], string> DataInterpreterBytes { get; set; }
-        public DateTime? DisconnectTime { get; set; }
+//        public DateTime? DisconnectTime { get; set; }
-        public string Url { get; }
+//        public string Url { get; }
-        public bool IsClosed => !Connected;
+//        public bool IsClosed => !Connected;
-        public bool IsOpen => Connected;
+//        public bool IsOpen => Connected;
-        public bool PingConnection { get; set; }
+//        public bool PingConnection { get; set; }
-        public TimeSpan PingInterval { get; set; }
+//        public TimeSpan PingInterval { get; set; }
-        public SslProtocols SSLProtocols { get; set; }
+//        public SslProtocols SSLProtocols { get; set; }
-        public Encoding Encoding { get; set; }
+//        public Encoding Encoding { get; set; }
 
-        public int ConnectCalls { get; private set; }
+//        public int ConnectCalls { get; private set; }
-        public bool Reconnecting { get; set; }
+//        public bool Reconnecting { get; set; }
-        public string Origin { get; set; }
+//        public string Origin { get; set; }
-        public int? RatelimitPerSecond { get; set; }
+//        public int? RatelimitPerSecond { get; set; }
 
-        public double IncomingKbps => throw new NotImplementedException();
+//        public double IncomingKbps => throw new NotImplementedException();
 
-        public static int lastId = 0;
+//        public Uri Uri => new Uri("");
-        public static object lastIdLock = new object();
 
-        public TestSocket()
+//        public TimeSpan KeepAliveInterval { get; set; }
-        {
-            lock (lastIdLock)
-            {
-                Id = lastId + 1;
-                lastId++;
-            }
-        }
 
-        public Task<bool> ConnectAsync()
+//        public static int lastId = 0;
-        {
+//        public static object lastIdLock = new object();
-            Connected = CanConnect;
-            ConnectCalls++;
-            if (CanConnect)
-                InvokeOpen();
-            return Task.FromResult(CanConnect);
-        }
 
-        public void Send(string data)
+//        public TestSocket()
-        {
+//        {
-            if(!Connected)
+//            lock (lastIdLock)
-                throw new Exception("Socket not connected");
+//            {
-        }
+//                Id = lastId + 1;
+//                lastId++;
+//            }
+//        }
 
-        public void Reset()
+//        public Task<CallResult> ConnectAsync()
-        {
+//        {
-        }
+//            Connected = CanConnect;
+//            ConnectCalls++;
+//            if (CanConnect)
+//                InvokeOpen();
+//            return Task.FromResult(CanConnect ? new CallResult(null) : new CallResult(new CantConnectError()));
+//        }
 
-        public Task CloseAsync()
+//        public bool Send(int requestId, string data, int weight)
-        {
+//        {
-            Connected = false;
+//            if(!Connected)
-            DisconnectTime = DateTime.UtcNow;
+//                throw new Exception("Socket not connected");
-            OnClose?.Invoke();
+//            OnRequestSent?.Invoke(requestId);
-            return Task.FromResult(0);
+//            return true;
-        }
+//        }
 
-        public void SetProxy(string host, int port)
+//        public void Reset()
-        {
+//        {
-            throw new NotImplementedException();
+//        }
-        }
-        public void Dispose()
-        {
-        }
 
-        public void InvokeClose()
+//        public Task CloseAsync()
-        {
+//        {
-            Connected = false;
+//            Connected = false;
-            DisconnectTime = DateTime.UtcNow;
+//            DisconnectTime = DateTime.UtcNow;
-            OnClose?.Invoke();
+//            OnClose?.Invoke();
-        }
+//            return Task.FromResult(0);
+//        }
 
-        public void InvokeOpen()
+//        public void SetProxy(string host, int port)
-        {
+//        {
-            OnOpen?.Invoke();
+//            throw new NotImplementedException();
-        }
+//        }
+//        public void Dispose()
+//        {
+//        }
 
-        public void InvokeMessage(string data)
+//        public void InvokeClose()
-        {
+//        {
-            OnMessage?.Invoke(data);
+//            Connected = false;
-        }
+//            DisconnectTime = DateTime.UtcNow;
+//            Reconnecting = true;
+//            OnClose?.Invoke();
+//        }
 
-        public void SetProxy(ApiProxy proxy)
+//        public void InvokeOpen()
-        {
+//        {
-            throw new NotImplementedException();
+//            OnOpen?.Invoke();
-        }
+//        }
 
-        public void InvokeError(Exception error)
+//        public void InvokeMessage(string data)
-        {
+//        {
-            OnError?.Invoke(error);
+//            OnStreamMessage?.Invoke(WebSocketMessageType.Text, new ReadOnlyMemory<byte>(Encoding.UTF8.GetBytes(data))).Wait();
-        }
+//        }
-    }
+
-}
+//        public void SetProxy(ApiProxy proxy)
+//        {
+//            throw new NotImplementedException();
+//        }
+
+//        public void InvokeError(Exception error)
+//        {
+//            OnError?.Invoke(error);
+//        }
+//        public Task ReconnectAsync() => Task.CompletedTask;
+//    }
+//}

CryptoExchange.Net.UnitTests/TestImplementations/TestSocketClient.cs

@@ -1,66 +1,135 @@
 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.Logging;
 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 Newtonsoft.Json.Linq;
+using CryptoExchange.Net.Testing.Implementations;
+using CryptoExchange.Net.SharedApis;
+using Microsoft.Extensions.Options;
 
 namespace CryptoExchange.Net.UnitTests.TestImplementations
 {
-    public class TestSocketClient: SocketClient
+    internal class TestSocketClient: BaseSocketClient
     {
-        public TestSocketClient() : this(new SocketClientOptions("http://testurl.url"))
+        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(SocketClientOptions exchangeOptions) : base("test", exchangeOptions, exchangeOptions.ApiCredentials == null ? null : new TestAuthProvider(exchangeOptions.ApiCredentials))
+        public TestSocketClient(IOptions<TestSocketOptions> options, ILoggerFactory loggerFactory = null) : base(loggerFactory, "Test")
         {
-            SocketFactory = new Mock<IWebsocketFactory>().Object;
+            Initialize(options.Value);
-            Mock.Get(SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<Log>(), It.IsAny<string>())).Returns(new TestSocket());
+
+            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(SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<Log>(), It.IsAny<string>())).Returns(new TestSocket());
+            Mock.Get(SubClient.SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<ILogger>(), It.IsAny<WebSocketParameters>())).Returns(new TestSocket("https://test.com"));
-            return (TestSocket)CreateSocket(BaseAddress);
+            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 CallResult<bool> ConnectSocketSub(SocketConnection sub)
+        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)
+        {
+
+        }
+
+        /// <inheritdoc />
+        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode futuresType, DateTime? deliverDate = null) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
+
+        internal IWebsocket CreateSocketInternal(string address)
+        {
+            return CreateSocket(address);
+        }
+
+        protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials)
+            => new TestAuthProvider(credentials);
+
+        public CallResult ConnectSocketSub(SocketConnection sub)
         {
             return ConnectSocketAsync(sub).Result;
         }
 
-        protected internal override bool HandleQueryResponse<T>(SocketConnection s, object request, JToken data, out CallResult<T> callResult)
+        public override string GetListenerIdentifier(IMessageAccessor message)
         {
-            throw new NotImplementedException();
+            if (!message.IsJson)
+            {
+                return "topic";
+            }
+
+            var id = message.GetValue<string>(_channelPath);
+            id ??= message.GetValue<string>(_topicPath);
+
+            return message.GetValue<string>(_actionPath) + "-" + id;
         }
 
-        protected internal override bool HandleSubscriptionResponse(SocketConnection s, SocketSubscription subscription, object request, JToken message,
+        public Task<CallResult<UpdateSubscription>> SubscribeToSomethingAsync(string channel, Action<DataEvent<string>> onUpdate, CancellationToken ct)
-            out CallResult<object> callResult)
         {
-            throw new NotImplementedException();
+            TestSubscription = new TestSubscriptionWithResponseCheck<string>(channel, onUpdate);
-        }
+            return SubscribeAsync(TestSubscription, ct);
-
+        }        
-        protected internal override bool MessageMatchesHandler(JToken message, object request)
-        {
-            throw new NotImplementedException();
-        }
-
-        protected internal override bool MessageMatchesHandler(JToken message, string identifier)
-        {
-            return true;
-        }
-
-        protected internal override Task<CallResult<bool>> AuthenticateSocketAsync(SocketConnection s)
-        {
-            throw new NotImplementedException();
-        }
-
-        protected internal override Task<bool> UnsubscribeAsync(SocketConnection connection, SocketSubscription s)
-        {
-            throw new NotImplementedException();
-        }
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/TestStringLogger.cs

@@ -1,25 +0,0 @@
-using Microsoft.Extensions.Logging;
-using System;
-using System.Text;
-
-namespace CryptoExchange.Net.UnitTests.TestImplementations
-{
-    public class TestStringLogger : ILogger
-    {
-        StringBuilder _builder = new StringBuilder();
-
-        public IDisposable BeginScope<TState>(TState state) => null;
-
-        public bool IsEnabled(LogLevel logLevel) => true;
-
-        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
-        {
-            _builder.AppendLine(formatter(state, exception));
-        }
-
-        public string GetLogs()
-        {
-            return _builder.ToString();
-        }
-    }
-}

CryptoExchange.Net.sln

@@ -1,12 +1,20 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
+# Visual Studio Version 17
-VisualStudioVersion = 15.0.27004.2008
+VisualStudioVersion = 17.0.32014.148
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CryptoExchange.Net", "CryptoExchange.Net\CryptoExchange.Net.csproj", "{3762140C-7FF9-46E5-8EC3-BFB3FC7ADB9B}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CryptoExchange.Net.UnitTests", "CryptoExchange.Net.UnitTests\CryptoExchange.Net.UnitTests.csproj", "{FBFE1651-D43D-4D67-89B7-6C4AE9BA4496}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "BlazorClient", "Examples\BlazorClient\BlazorClient.csproj", "{AF4F5C19-162E-48F4-8B0B-BA5A2D7CE06A}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Examples", "Examples", "{5734C2A9-F12C-4754-A8B9-640C24DC4E02}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ConsoleClient", "Examples\ConsoleClient\ConsoleClient.csproj", "{23480C58-23BF-4EBF-A173-B7F51A043A99}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharedClients", "Examples\SharedClients\SharedClients.csproj", "{988A87EF-EAEA-4313-A6CF-FA869813D5AB}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -21,10 +29,27 @@ Global
 		{FBFE1651-D43D-4D67-89B7-6C4AE9BA4496}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{FBFE1651-D43D-4D67-89B7-6C4AE9BA4496}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{FBFE1651-D43D-4D67-89B7-6C4AE9BA4496}.Release|Any CPU.Build.0 = Release|Any CPU
+		{AF4F5C19-162E-48F4-8B0B-BA5A2D7CE06A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{AF4F5C19-162E-48F4-8B0B-BA5A2D7CE06A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{AF4F5C19-162E-48F4-8B0B-BA5A2D7CE06A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{AF4F5C19-162E-48F4-8B0B-BA5A2D7CE06A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{23480C58-23BF-4EBF-A173-B7F51A043A99}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{23480C58-23BF-4EBF-A173-B7F51A043A99}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{23480C58-23BF-4EBF-A173-B7F51A043A99}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{23480C58-23BF-4EBF-A173-B7F51A043A99}.Release|Any CPU.Build.0 = Release|Any CPU
+		{988A87EF-EAEA-4313-A6CF-FA869813D5AB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{988A87EF-EAEA-4313-A6CF-FA869813D5AB}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{988A87EF-EAEA-4313-A6CF-FA869813D5AB}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{988A87EF-EAEA-4313-A6CF-FA869813D5AB}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{AF4F5C19-162E-48F4-8B0B-BA5A2D7CE06A} = {5734C2A9-F12C-4754-A8B9-640C24DC4E02}
+		{23480C58-23BF-4EBF-A173-B7F51A043A99} = {5734C2A9-F12C-4754-A8B9-640C24DC4E02}
+		{988A87EF-EAEA-4313-A6CF-FA869813D5AB} = {5734C2A9-F12C-4754-A8B9-640C24DC4E02}
+	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {0D1B9CE9-E0B7-4B8B-88BF-6EA2CC8CA3D7}
 	EndGlobalSection

CryptoExchange.Net/AssemblyInfo.cs

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

CryptoExchange.Net/Attributes/JsonConversionAttribute.cs

@@ -5,6 +5,7 @@ namespace CryptoExchange.Net.Attributes
     /// <summary>
     /// Used for conversion in ArrayConverter
     /// </summary>
+    [AttributeUsage(AttributeTargets.Property)]
     public class JsonConversionAttribute: Attribute
     {
     }

CryptoExchange.Net/Attributes/JsonOptionalPropertyAttribute.cs

@@ -1,11 +0,0 @@
-using System;
-
-namespace CryptoExchange.Net.Attributes
-{
-    /// <summary>
-    /// Marks property as optional
-    /// </summary>
-    public class JsonOptionalPropertyAttribute : Attribute
-    {
-    }
-}

CryptoExchange.Net/Attributes/MapAttribute.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace CryptoExchange.Net.Attributes
+{
+    /// <summary>
+    /// Map a enum entry to string values
+    /// </summary>
+    public class MapAttribute : Attribute
+    {
+        /// <summary>
+        /// Values mapping to the enum entry
+        /// </summary>
+        public string[] Values { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="maps"></param>
+        public MapAttribute(params string[] maps)
+        {
+            Values = maps;
+        }
+    }
+}

CryptoExchange.Net/Authentication/ApiCredentials.cs

@@ -1,78 +1,53 @@
 using System;
 using System.IO;
-using System.Security;
+using CryptoExchange.Net.Converters.SystemTextJson;
-using System.Text;
+using CryptoExchange.Net.Converters.MessageParsing;
-using Newtonsoft.Json.Linq;
 
 namespace CryptoExchange.Net.Authentication
 {
     /// <summary>
-    /// Api credentials info
+    /// Api credentials, used to sign requests accessing private endpoints
     /// </summary>
-    public class ApiCredentials: IDisposable
+    public class ApiCredentials
     {
         /// <summary>
-        /// The api key to authenticate requests
+        /// The api key / label to authenticate requests
         /// </summary>
-        public SecureString? Key { get; }
+        public string Key { get; set; }
 
         /// <summary>
-        /// The api secret to authenticate requests
+        /// The api secret or private key to authenticate requests
         /// </summary>
-        public SecureString? Secret { get; }
+        public string Secret { get; set; }
 
         /// <summary>
-        /// The private key to authenticate requests
+        /// Type of the credentials
         /// </summary>
-        public PrivateKey? PrivateKey { get; }
+        public ApiCredentialsType CredentialType { get; set; }
-
-        /// <summary>
-        /// Create Api credentials providing a private key for authentication
-        /// </summary>
-        /// <param name="privateKey">The private key used for signing</param>
-        public ApiCredentials(PrivateKey privateKey)
-        {
-            PrivateKey = privateKey;
-        }
 
         /// <summary>
         /// Create Api credentials providing an api key and secret for authentication
         /// </summary>
-        /// <param name="key">The api key used for identification</param>
+        /// <param name="key">The api key / label used for identification</param>
-        /// <param name="secret">The api secret used for signing</param>
+        /// <param name="secret">The api secret or private key used for signing</param>
-        public ApiCredentials(SecureString key, SecureString secret)
+        /// <param name="credentialType">The type of credentials</param>
-        {
+        public ApiCredentials(string key, string secret, ApiCredentialsType credentialType = ApiCredentialsType.Hmac)
-            if (key == null || secret == null)
-                throw new ArgumentException("Key and secret can't be null/empty");
-
-            Key = key;
-            Secret = secret;
-        }
-
-        /// <summary>
-        /// Create Api credentials providing an api key and secret for authentication
-        /// </summary>
-        /// <param name="key">The api key used for identification</param>
-        /// <param name="secret">The api secret used for signing</param>
-        public ApiCredentials(string key, string secret)
         {
             if (string.IsNullOrEmpty(key) || string.IsNullOrEmpty(secret))
                 throw new ArgumentException("Key and secret can't be null/empty");
 
-            Key = key.ToSecureString();
+            CredentialType = credentialType;
-            Secret = secret.ToSecureString();
+            Key = key;
+            Secret = secret;
         }
 
         /// <summary>
         /// Copy the credentials
         /// </summary>
         /// <returns></returns>
-        public ApiCredentials Copy()
+        public virtual ApiCredentials Copy()
         {
-            if (PrivateKey == null)
+            return new ApiCredentials(Key, Secret, CredentialType);
-                return new ApiCredentials(Key!.GetString(), Secret!.GetString());
-            else
-                return new ApiCredentials(PrivateKey!.Copy());
         }
 
         /// <summary>
@@ -81,48 +56,19 @@ namespace CryptoExchange.Net.Authentication
         /// <param name="inputStream">The stream containing the json data</param>
         /// <param name="identifierKey">A key to identify the credentials for the API. For example, when set to `binanceKey` the json data should contain a value for the property `binanceKey`. Defaults to 'apiKey'.</param>
         /// <param name="identifierSecret">A key to identify the credentials for the API. For example, when set to `binanceSecret` the json data should contain a value for the property `binanceSecret`. Defaults to 'apiSecret'.</param>
-        public ApiCredentials(Stream inputStream, string? identifierKey = null, string? identifierSecret = null)
+        public static ApiCredentials FromStream(Stream inputStream, string? identifierKey = null, string? identifierSecret = null)
         {
-            using var reader = new StreamReader(inputStream, Encoding.UTF8, false, 512, true);
+            var accessor = new SystemTextJsonStreamMessageAccessor();
-            
+            if (!accessor.Read(inputStream, false).Result)
-            var stringData = reader.ReadToEnd();
-            var jsonData = stringData.ToJToken();
-            if(jsonData == null)
                 throw new ArgumentException("Input stream not valid json data");
 
-            var key = TryGetValue(jsonData, identifierKey ?? "apiKey");
+            var key = accessor.GetValue<string>(MessagePath.Get().Property(identifierKey ?? "apiKey"));
-            var secret = TryGetValue(jsonData, identifierSecret ?? "apiSecret");
+            var secret = accessor.GetValue<string>(MessagePath.Get().Property(identifierSecret ?? "apiSecret"));
-
             if (key == null || secret == null)
                 throw new ArgumentException("apiKey or apiSecret value not found in Json credential file");
-
+            
-            Key = key.ToSecureString();
-            Secret = secret.ToSecureString();            
-
             inputStream.Seek(0, SeekOrigin.Begin);
-        }
+            return new ApiCredentials(key, secret);
-
-        /// <summary>
-        /// Try get the value of a key from a JToken
-        /// </summary>
-        /// <param name="data"></param>
-        /// <param name="key"></param>
-        /// <returns></returns>
-        protected string? TryGetValue(JToken data, string key)
-        {
-            if (data[key] == null)
-                return null;
-            return (string) data[key]!;
-        }       
-
-        /// <summary>
-        /// Dispose
-        /// </summary>
-        public void Dispose()
-        {
-            Key?.Dispose();
-            Secret?.Dispose();
-            PrivateKey?.Dispose();
         }
     }
 }

CryptoExchange.Net/Authentication/ApiCredentialsType.cs

@@ -0,0 +1,21 @@
+namespace CryptoExchange.Net.Authentication
+{
+    /// <summary>
+    /// Credentials type
+    /// </summary>
+    public enum ApiCredentialsType
+    {
+        /// <summary>
+        /// Hmac keys credentials
+        /// </summary>
+        Hmac,
+        /// <summary>
+        /// Rsa keys credentials in xml format
+        /// </summary>
+        RsaXml,
+        /// <summary>
+        /// Rsa keys credentials in pem/base64 format. Only available for .NetStandard 2.1 and up, use xml format for lower.
+        /// </summary>
+        RsaPem
+    }
+}

CryptoExchange.Net/Authentication/AuthenticationProvider.cs

@@ -1,6 +1,13 @@
-using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Clients;
+using CryptoExchange.Net.Converters.SystemTextJson;
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects;
+using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Net.Http;
+using System.Security.Cryptography;
+using System.Text;
 
 namespace CryptoExchange.Net.Authentication
 {
@@ -9,10 +16,22 @@ namespace CryptoExchange.Net.Authentication
     /// </summary>
     public abstract class AuthenticationProvider
     {
+        internal IAuthTimeProvider TimeProvider { get; set; } = new AuthTimeProvider();
+
         /// <summary>
-        /// The provided credentials
+        /// Provided credentials
         /// </summary>
-        public ApiCredentials Credentials { get; }
+        protected internal readonly ApiCredentials _credentials;
+
+        /// <summary>
+        /// Byte representation of the secret
+        /// </summary>
+        protected byte[] _sBytes;
+
+        /// <summary>
+        /// Get the API key of the current credentials
+        /// </summary>
+        public string ApiKey => _credentials.Key!;
 
         /// <summary>
         /// ctor
@@ -20,72 +39,433 @@ namespace CryptoExchange.Net.Authentication
         /// <param name="credentials"></param>
         protected AuthenticationProvider(ApiCredentials credentials)
         {
-            Credentials = credentials;
+            if (credentials.Key == null || credentials.Secret == null)
+                throw new ArgumentException("ApiKey/Secret needed");
+
+            _credentials = credentials;
+            _sBytes = Encoding.UTF8.GetBytes(credentials.Secret);
         }
 
         /// <summary>
-        /// Add authentication to the parameter list based on the provided credentials
+        /// Authenticate a request. Output parameters should include the providedParameters input
         /// </summary>
-        /// <param name="uri">The uri the request is for</param>
+        /// <param name="apiClient">The Api client sending the request</param>
-        /// <param name="method">The HTTP method of the request</param>
+        /// <param name="uri">The uri for the request</param>
-        /// <param name="parameters">The provided parameters for the request</param>
+        /// <param name="method">The method of the request</param>
-        /// <param name="signed">Wether or not the request needs to be signed. If not typically the parameters list can just be returned</param>
+        /// <param name="auth">If the requests should be authenticated</param>
-        /// <param name="parameterPosition">Where parameters are placed, in the URI or in the request body</param>
+        /// <param name="arraySerialization">Array serialization type</param>
-        /// <param name="arraySerialization">How array parameters are serialized</param>
+        /// <param name="requestBodyFormat">The formatting of the request body</param>
-        /// <returns>Should return the original parameter list including any authentication parameters needed</returns>
+        /// <param name="uriParameters">Parameters that need to be in the Uri of the request. Should include the provided parameters if they should go in the uri</param>
-        public virtual Dictionary<string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary<string, object> parameters, bool signed,
+        /// <param name="bodyParameters">Parameters that need to be in the body of the request. Should include the provided parameters if they should go in the body</param>
-            HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
+        /// <param name="headers">The headers that should be send with the request</param>
-        {
+        /// <param name="parameterPosition">The position where the providedParameters should go</param>
-            return parameters;
+        public abstract void AuthenticateRequest(
-        }
+            RestApiClient apiClient,
+            Uri uri,
+            HttpMethod method,
+            ref IDictionary<string, object>? uriParameters,
+            ref IDictionary<string, object>? bodyParameters,
+            ref Dictionary<string, string>? headers,
+            bool auth,
+            ArrayParametersSerialization arraySerialization,
+            HttpMethodParameterPosition parameterPosition,
+            RequestBodyFormat requestBodyFormat
+            );
 
         /// <summary>
-        /// Add authentication to the header dictionary based on the provided credentials
+        /// SHA256 sign the data and return the bytes
         /// </summary>
-        /// <param name="uri">The uri the request is for</param>
+        /// <param name="data"></param>
-        /// <param name="method">The HTTP method of the request</param>
-        /// <param name="parameters">The provided parameters for the request</param>
-        /// <param name="signed">Wether or not the request needs to be signed. If not typically the parameters list can just be returned</param>
-        /// <param name="parameterPosition">Where post parameters are placed, in the URI or in the request body</param>
-        /// <param name="arraySerialization">How array parameters are serialized</param>
-        /// <returns>Should return a dictionary containing any header key/value pairs needed for authenticating the request</returns>
-        public virtual Dictionary<string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary<string, object> parameters, bool signed,
-            HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
-        {
-            return new Dictionary<string, string>();
-        }
-
-        /// <summary>
-        /// Sign a string
-        /// </summary>
-        /// <param name="toSign"></param>
         /// <returns></returns>
-        public virtual string Sign(string toSign)
+        protected static byte[] SignSHA256Bytes(string data)
         {
-            return toSign;
+            using var encryptor = SHA256.Create();
+            return encryptor.ComputeHash(Encoding.UTF8.GetBytes(data));
         }
 
         /// <summary>
-        /// Sign a byte array
+        /// SHA256 sign the data and return the bytes
         /// </summary>
-        /// <param name="toSign"></param>
+        /// <param name="data"></param>
         /// <returns></returns>
-        public virtual byte[] Sign(byte[] toSign)
+        protected static byte[] SignSHA256Bytes(byte[] data)
         {
-            return toSign;
+            using var encryptor = SHA256.Create();
+            return encryptor.ComputeHash(data);
         }
 
         /// <summary>
-        /// Convert byte array to hex
+        /// SHA256 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected static string SignSHA256(string data, SignOutputType? outputType = null)
+        {
+            using var encryptor = SHA256.Create();
+            var resultBytes = encryptor.ComputeHash(Encoding.UTF8.GetBytes(data));
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+        }
+
+        /// <summary>
+        /// SHA256 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected static string SignSHA256(byte[] data, SignOutputType? outputType = null)
+        {
+            using var encryptor = SHA256.Create();
+            var resultBytes = encryptor.ComputeHash(data);
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+        }
+
+        /// <summary>
+        /// SHA384 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected static string SignSHA384(string data, SignOutputType? outputType = null)
+        {
+            using var encryptor = SHA384.Create();
+            var resultBytes = encryptor.ComputeHash(Encoding.UTF8.GetBytes(data));
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+        }
+
+        /// <summary>
+        /// SHA384 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected static string SignSHA384(byte[] data, SignOutputType? outputType = null)
+        {
+            using var encryptor = SHA384.Create();
+            var resultBytes = encryptor.ComputeHash(data);
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+        }
+
+        /// <summary>
+        /// SHA384 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <returns></returns>
+        protected static byte[] SignSHA384Bytes(string data)
+        {
+            using var encryptor = SHA384.Create();
+            return encryptor.ComputeHash(Encoding.UTF8.GetBytes(data));
+        }
+
+        /// <summary>
+        /// SHA384 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <returns></returns>
+        protected static byte[] SignSHA384Bytes(byte[] data)
+        {
+            using var encryptor = SHA384.Create();
+            return encryptor.ComputeHash(data);
+        }
+
+        /// <summary>
+        /// SHA512 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected static string SignSHA512(string data, SignOutputType? outputType = null)
+        {
+            using var encryptor = SHA512.Create();
+            var resultBytes = encryptor.ComputeHash(Encoding.UTF8.GetBytes(data));
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+        }
+
+        /// <summary>
+        /// SHA512 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected static string SignSHA512(byte[] data, SignOutputType? outputType = null)
+        {
+            using var encryptor = SHA512.Create();
+            var resultBytes = encryptor.ComputeHash(data);
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+        }
+
+        /// <summary>
+        /// SHA512 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <returns></returns>
+        protected static byte[] SignSHA512Bytes(string data)
+        {
+            using var encryptor = SHA512.Create();
+            return encryptor.ComputeHash(Encoding.UTF8.GetBytes(data));
+        }
+
+        /// <summary>
+        /// SHA512 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <returns></returns>
+        protected static byte[] SignSHA512Bytes(byte[] data)
+        {
+            using var encryptor = SHA512.Create();
+            return encryptor.ComputeHash(data);
+        }
+
+        /// <summary>
+        /// MD5 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected static string SignMD5(string data, SignOutputType? outputType = null)
+        {
+            using var encryptor = MD5.Create();
+            var resultBytes = encryptor.ComputeHash(Encoding.UTF8.GetBytes(data));
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+        }
+
+        /// <summary>
+        /// MD5 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected static string SignMD5(byte[] data, SignOutputType? outputType = null)
+        {
+            using var encryptor = MD5.Create();
+            var resultBytes = encryptor.ComputeHash(data);
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+        }
+
+        /// <summary>
+        /// MD5 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <returns></returns>
+        protected static byte[] SignMD5Bytes(string data)
+        {
+            using var encryptor = MD5.Create();
+            return encryptor.ComputeHash(Encoding.UTF8.GetBytes(data));
+        }
+
+        /// <summary>
+        /// HMACSHA256 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected string SignHMACSHA256(string data, SignOutputType? outputType = null)
+            => SignHMACSHA256(Encoding.UTF8.GetBytes(data), outputType);
+
+        /// <summary>
+        /// HMACSHA256 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected string SignHMACSHA256(byte[] data, SignOutputType? outputType = null)
+        {
+            using var encryptor = new HMACSHA256(_sBytes);
+            var resultBytes = encryptor.ComputeHash(data);
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+        }
+
+        /// <summary>
+        /// HMACSHA384 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected string SignHMACSHA384(string data, SignOutputType? outputType = null)
+            => SignHMACSHA384(Encoding.UTF8.GetBytes(data), outputType);
+
+        /// <summary>
+        /// HMACSHA384 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected string SignHMACSHA384(byte[] data, SignOutputType? outputType = null)
+        {
+            using var encryptor = new HMACSHA384(_sBytes);
+            var resultBytes = encryptor.ComputeHash(data);
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+        }
+
+        /// <summary>
+        /// HMACSHA512 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected string SignHMACSHA512(string data, SignOutputType? outputType = null)
+            => SignHMACSHA512(Encoding.UTF8.GetBytes(data), outputType);
+
+        /// <summary>
+        /// HMACSHA512 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected string SignHMACSHA512(byte[] data, SignOutputType? outputType = null)
+        {
+            using var encryptor = new HMACSHA512(_sBytes);
+            var resultBytes = encryptor.ComputeHash(data);
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+        }
+
+        /// <summary>
+        /// SHA256 sign the data
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="outputType"></param>
+        /// <returns></returns>
+        protected string SignRSASHA256(byte[] data, SignOutputType? outputType = null)
+        {
+            using var rsa = CreateRSA();
+            using var sha256 = SHA256.Create();
+            var hash = sha256.ComputeHash(data);
+            var resultBytes = rsa.SignHash(hash, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
+            return outputType == SignOutputType.Base64? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+        }
+
+        /// <summary>
+        /// SHA384 sign the data
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="outputType"></param>
+        /// <returns></returns>
+        protected string SignRSASHA384(byte[] data, SignOutputType? outputType = null)
+        {
+            using var rsa = CreateRSA();
+            using var sha384 = SHA384.Create();
+            var hash = sha384.ComputeHash(data);
+            var resultBytes = rsa.SignHash(hash, HashAlgorithmName.SHA384, RSASignaturePadding.Pkcs1);
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+        }
+
+        /// <summary>
+        /// SHA512 sign the data
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="outputType"></param>
+        /// <returns></returns>
+        protected string SignRSASHA512(byte[] data, SignOutputType? outputType = null)
+        {
+            using var rsa = CreateRSA();
+            using var sha512 = SHA512.Create();
+            var hash = sha512.ComputeHash(data);
+            var resultBytes = rsa.SignHash(hash, HashAlgorithmName.SHA512, RSASignaturePadding.Pkcs1);
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+        }
+
+        private RSA CreateRSA()
+        {
+            var rsa = RSA.Create();
+            if (_credentials.CredentialType == ApiCredentialsType.RsaPem)
+            {
+#if NETSTANDARD2_1_OR_GREATER
+                // Read from pem private key
+                var key = _credentials.Secret!
+                        .Replace("\n", "")
+                        .Replace("-----BEGIN PRIVATE KEY-----", "")
+                        .Replace("-----END PRIVATE KEY-----", "")
+                        .Trim();
+                rsa.ImportPkcs8PrivateKey(Convert.FromBase64String(
+                    key)
+                    , out _);
+#else
+                throw new Exception("Pem format not supported when running from .NetStandard2.0. Convert the private key to xml format.");
+#endif
+            }
+            else if (_credentials.CredentialType == ApiCredentialsType.RsaXml)
+            {
+                // Read from xml private key format
+                rsa.FromXmlString(_credentials.Secret!);
+            }
+            else
+            {
+                throw new Exception("Invalid credentials type");
+            }
+
+            return rsa;
+        }
+
+        /// <summary>
+        /// Convert byte array to hex string
         /// </summary>
         /// <param name="buff"></param>
         /// <returns></returns>
-        protected static string ByteToString(byte[] buff)
+        protected static string BytesToHexString(byte[] buff)
         {
             var result = string.Empty;
             foreach (var t in buff)
-                result += t.ToString("X2"); /* hex format */
+                result += t.ToString("X2");
             return result;
         }
+
+        /// <summary>
+        /// Convert byte array to base64 string
+        /// </summary>
+        /// <param name="buff"></param>
+        /// <returns></returns>
+        protected static string BytesToBase64String(byte[] buff)
+        {
+            return Convert.ToBase64String(buff);
+        }
+
+        /// <summary>
+        /// Get current timestamp including the time sync offset from the api client
+        /// </summary>
+        /// <param name="apiClient"></param>
+        /// <returns></returns>
+        protected DateTime GetTimestamp(RestApiClient apiClient)
+        {
+            return TimeProvider.GetTime().Add(apiClient.GetTimeOffset() ?? TimeSpan.Zero)!;
+        }
+
+        /// <summary>
+        /// Get millisecond timestamp as a string including the time sync offset from the api client
+        /// </summary>
+        /// <param name="apiClient"></param>
+        /// <returns></returns>
+        protected string GetMillisecondTimestamp(RestApiClient apiClient)
+        {
+            return DateTimeConverter.ConvertToMilliseconds(GetTimestamp(apiClient)).Value.ToString(CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Return the serialized request body
+        /// </summary>
+        /// <param name="serializer"></param>
+        /// <param name="parameters"></param>
+        /// <returns></returns>
+        protected string GetSerializedBody(IMessageSerializer serializer, IDictionary<string, object> parameters)
+        {
+            if (parameters.Count == 1 && parameters.ContainsKey(Constants.BodyPlaceHolderKey))
+                return serializer.Serialize(parameters[Constants.BodyPlaceHolderKey]);
+            else
+                return serializer.Serialize(parameters);
+        }
+    }
+
+    /// <inheritdoc />
+    public abstract class AuthenticationProvider<TApiCredentials> : AuthenticationProvider where TApiCredentials : ApiCredentials
+    {
+        /// <inheritdoc />
+        protected new TApiCredentials _credentials => (TApiCredentials)base._credentials;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="credentials"></param>
+        protected AuthenticationProvider(TApiCredentials credentials) : base(credentials)
+        {
+        }
     }
 }

CryptoExchange.Net/Authentication/PrivateKey.cs

@@ -1,110 +0,0 @@
-using System;
-using System.Security;
-
-namespace CryptoExchange.Net.Authentication
-{
-    /// <summary>
-    /// Private key info
-    /// </summary>
-    public class PrivateKey : IDisposable
-    {
-        /// <summary>
-        /// The private key
-        /// </summary>
-        public SecureString Key { get; }
-
-        /// <summary>
-        /// The private key's pass phrase
-        /// </summary>
-        public SecureString? Passphrase { get; }
-
-        /// <summary>
-        /// Indicates if the private key is encrypted or not
-        /// </summary>
-        public bool IsEncrypted { get; }
-
-        /// <summary>
-        /// Create a private key providing an encrypted key information
-        /// </summary>
-        /// <param name="key">The private key used for signing</param>
-        /// <param name="passphrase">The private key's passphrase</param>
-        public PrivateKey(SecureString key, SecureString passphrase)
-        {
-            Key = key;
-            Passphrase = passphrase;
-
-            IsEncrypted = true;
-        }
-
-        /// <summary>
-        /// Create a private key providing an encrypted key information
-        /// </summary>
-        /// <param name="key">The private key used for signing</param>
-        /// <param name="passphrase">The private key's passphrase</param>
-        public PrivateKey(string key, string passphrase)
-        {
-            if (string.IsNullOrEmpty(key) || string.IsNullOrEmpty(passphrase))
-                throw new ArgumentException("Key and passphrase can't be null/empty");
-
-            var secureKey = new SecureString();
-            foreach (var c in key)
-                secureKey.AppendChar(c);
-            secureKey.MakeReadOnly();
-            Key = secureKey;
-
-            var securePassphrase = new SecureString();
-            foreach (var c in passphrase)
-                securePassphrase.AppendChar(c);
-            securePassphrase.MakeReadOnly();
-            Passphrase = securePassphrase;
-
-            IsEncrypted = true;
-        }
-
-        /// <summary>
-        /// Create a private key providing an unencrypted key information
-        /// </summary>
-        /// <param name="key">The private key used for signing</param>
-        public PrivateKey(SecureString key)
-        {
-            Key = key;
-
-            IsEncrypted = false;
-        }
-
-        /// <summary>
-        /// Create a private key providing an encrypted key information
-        /// </summary>
-        /// <param name="key">The private key used for signing</param>
-        public PrivateKey(string key)
-        {
-            if (string.IsNullOrEmpty(key))
-                throw new ArgumentException("Key can't be null/empty");
-
-            Key = key.ToSecureString();
-
-            IsEncrypted = false;
-        }
-
-        /// <summary>
-        /// Copy the private key
-        /// </summary>
-        /// <returns></returns>
-        public PrivateKey Copy()
-        {
-            if (Passphrase == null)
-                return new PrivateKey(Key.GetString());
-            else
-                return new PrivateKey(Key.GetString(), Passphrase.GetString());
-        }
-
-        /// <summary>
-        /// Dispose
-        /// </summary>
-        public void Dispose()
-        {
-            Key?.Dispose();
-            Passphrase?.Dispose();
-        }
-    }
-}

CryptoExchange.Net/Authentication/SignOutputType.cs

@@ -0,0 +1,17 @@
+namespace CryptoExchange.Net.Authentication
+{
+    /// <summary>
+    /// Output string type
+    /// </summary>
+    public enum SignOutputType
+    {
+        /// <summary>
+        /// Hex string
+        /// </summary>
+        Hex,
+        /// <summary>
+        /// Base64 string
+        /// </summary>
+        Base64
+    }
+}

CryptoExchange.Net/BaseClient.cs

@@ -1,463 +0,0 @@
-using CryptoExchange.Net.Attributes;
-using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Logging;
-using CryptoExchange.Net.Objects;
-using Microsoft.Extensions.Logging;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net
-{
-    /// <summary>
-    /// The base for all clients, websocket client and rest client
-    /// </summary>
-    public abstract class BaseClient : IDisposable
-    {
-        /// <summary>
-        /// The address of the client
-        /// </summary>
-        public string BaseAddress { get; }
-        /// <summary>
-        /// The name of the exchange the client is for
-        /// </summary>
-        public string ExchangeName { get; }
-        /// <summary>
-        /// The log object
-        /// </summary>
-        protected internal Log log;
-        /// <summary>
-        /// The api proxy
-        /// </summary>
-        protected ApiProxy? apiProxy;
-        /// <summary>
-        /// The authentication provider
-        /// </summary>
-        protected internal AuthenticationProvider? authProvider;
-        /// <summary>
-        /// Should check objects for missing properties based on the model and the received JSON
-        /// </summary>
-        public bool ShouldCheckObjects { get; set; }
-        /// <summary>
-        /// If true, the CallResult and DataEvent objects should also contain the originally received json data in the OriginalDaa property
-        /// </summary>
-        public bool OutputOriginalData { get; private set; }
-        /// <summary>
-        /// The last used id, use NextId() to get the next id and up this
-        /// </summary>
-        protected static int lastId;
-        /// <summary>
-        /// Lock for id generating
-        /// </summary>
-        protected static object idLock = new object();
-
-        /// <summary>
-        /// A default serializer
-        /// </summary>
-        private static readonly JsonSerializer defaultSerializer = JsonSerializer.Create(new JsonSerializerSettings
-        {
-            DateTimeZoneHandling = DateTimeZoneHandling.Utc,
-            Culture = CultureInfo.InvariantCulture
-        });
-
-        /// <summary>
-        /// Last id used
-        /// </summary>
-        public static int LastId => lastId;
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="exchangeName">The name of the exchange this client is for</param>
-        /// <param name="options">The options for this client</param>
-        /// <param name="authenticationProvider">The authentication provider for this client (can be null if no credentials are provided)</param>
-        protected BaseClient(string exchangeName, ClientOptions options, AuthenticationProvider? authenticationProvider)
-        {
-            log = new Log(exchangeName);
-            authProvider = authenticationProvider;
-            log.UpdateWriters(options.LogWriters);
-            log.Level = options.LogLevel;
-
-            ExchangeName = exchangeName;
-            OutputOriginalData = options.OutputOriginalData;
-            BaseAddress = options.BaseAddress;
-            apiProxy = options.Proxy;
-
-            log.Write(LogLevel.Debug, $"Client configuration: {options}, CryptoExchange.Net: v{typeof(BaseClient).Assembly.GetName().Version}, {ExchangeName}.Net: v{GetType().Assembly.GetName().Version}");
-            ShouldCheckObjects = options.ShouldCheckObjects;
-        }
-
-        /// <summary>
-        /// Set the authentication provider, can be used when manually setting the API credentials
-        /// </summary>
-        /// <param name="authenticationProvider"></param>
-        protected void SetAuthenticationProvider(AuthenticationProvider authenticationProvider)
-        {
-            log.Write(LogLevel.Debug, "Setting api credentials");
-            authProvider = authenticationProvider;
-        }
-
-        /// <summary>
-        /// Tries to parse the json data and returns a JToken, validating the input not being empty and being valid json
-        /// </summary>
-        /// <param name="data">The data to parse</param>
-        /// <returns></returns>
-        protected CallResult<JToken> ValidateJson(string data)
-        {
-            if (string.IsNullOrEmpty(data))
-            {
-                var info = "Empty data object received";
-                log.Write(LogLevel.Error, info);
-                return new CallResult<JToken>(null, new DeserializeError(info, data));
-            }
-
-            try
-            {
-                return new CallResult<JToken>(JToken.Parse(data), null);
-            }
-            catch (JsonReaderException jre)
-            {
-                var info = $"Deserialize JsonReaderException: {jre.Message}, Path: {jre.Path}, LineNumber: {jre.LineNumber}, LinePosition: {jre.LinePosition}";
-                return new CallResult<JToken>(null, new DeserializeError(info, data));
-            }
-            catch (JsonSerializationException jse)
-            {
-                var info = $"Deserialize JsonSerializationException: {jse.Message}";
-                return new CallResult<JToken>(null, new DeserializeError(info, data));
-            }
-            catch (Exception ex)
-            {
-                var exceptionInfo = ex.ToLogString();
-                var info = $"Deserialize Unknown Exception: {exceptionInfo}";
-                return new CallResult<JToken>(null, new DeserializeError(info, data));
-            }
-        }
-
-        /// <summary>
-        /// Deserialize a string into an object
-        /// </summary>
-        /// <typeparam name="T">The type to deserialize into</typeparam>
-        /// <param name="data">The data to deserialize</param>
-        /// <param name="checkObject">Whether or not the parsing should be checked for missing properties (will output data to the logging if log verbosity is Debug)</param>
-        /// <param name="serializer">A specific serializer to use</param>
-        /// <param name="requestId">Id of the request the data is returned from (used for grouping logging by request)</param>
-        /// <returns></returns>
-        protected CallResult<T> Deserialize<T>(string data, bool? checkObject = null, JsonSerializer? serializer = null, int? requestId = null)
-        {
-            var tokenResult = ValidateJson(data);
-            if (!tokenResult)
-            {
-                log.Write(LogLevel.Error, tokenResult.Error!.Message);
-                return new CallResult<T>(default, tokenResult.Error);
-            }
-
-            return Deserialize<T>(tokenResult.Data, checkObject, serializer, requestId);
-        }
-
-        /// <summary>
-        /// Deserialize a JToken into an object
-        /// </summary>
-        /// <typeparam name="T">The type to deserialize into</typeparam>
-        /// <param name="obj">The data to deserialize</param>
-        /// <param name="checkObject">Whether or not the parsing should be checked for missing properties (will output data to the logging if log verbosity is Debug)</param>
-        /// <param name="serializer">A specific serializer to use</param>
-        /// <param name="requestId">Id of the request the data is returned from (used for grouping logging by request)</param>
-        /// <returns></returns>
-        protected CallResult<T> Deserialize<T>(JToken obj, bool? checkObject = null, JsonSerializer? serializer = null, int? requestId = null)
-        {
-            if (serializer == null)
-                serializer = defaultSerializer;
-
-            try
-            {
-                if ((checkObject ?? ShouldCheckObjects)&& log.Level <= LogLevel.Debug)
-                {
-                    // This checks the input JToken object against the class it is being serialized into and outputs any missing fields
-                    // in either the input or the class
-                    try
-                    {
-                        if (obj is JObject o)
-                        {
-                            CheckObject(typeof(T), o, requestId);
-                        }
-                        else if (obj is JArray j)
-                        {
-                            if (j.HasValues && j[0] is JObject jObject)
-                                CheckObject(typeof(T).GetElementType(), jObject, requestId);
-                        }
-                    }
-                    catch (Exception e)
-                    {
-                        log.Write(LogLevel.Debug, $"{(requestId != null ? $"[{ requestId}] " : "")}Failed to check response data: " + (e.InnerException?.Message ?? e.Message));
-                    }
-                }
-
-                return new CallResult<T>(obj.ToObject<T>(serializer), null);
-            }
-            catch (JsonReaderException jre)
-            {
-                var info = $"{(requestId != null ? $"[{requestId}] " : "")}Deserialize JsonReaderException: {jre.Message} Path: {jre.Path}, LineNumber: {jre.LineNumber}, LinePosition: {jre.LinePosition}, data: {obj}";
-                log.Write(LogLevel.Error, info);
-                return new CallResult<T>(default, new DeserializeError(info, obj));
-            }
-            catch (JsonSerializationException jse)
-            {
-                var info = $"{(requestId != null ? $"[{requestId}] " : "")}Deserialize JsonSerializationException: {jse.Message} data: {obj}";
-                log.Write(LogLevel.Error, info);
-                return new CallResult<T>(default, new DeserializeError(info, obj));
-            }
-            catch (Exception ex)
-            {
-                var exceptionInfo = ex.ToLogString();
-                var info = $"{(requestId != null ? $"[{requestId}] " : "")}Deserialize Unknown Exception: {exceptionInfo}, data: {obj}";
-                log.Write(LogLevel.Error, info);
-                return new CallResult<T>(default, new DeserializeError(info, obj));
-            }
-        }
-
-        /// <summary>
-        /// Deserialize a stream into an object
-        /// </summary>
-        /// <typeparam name="T">The type to deserialize into</typeparam>
-        /// <param name="stream">The stream to deserialize</param>
-        /// <param name="serializer">A specific serializer to use</param>
-        /// <param name="requestId">Id of the request the data is returned from (used for grouping logging by request)</param>
-        /// <param name="elapsedMilliseconds">Milliseconds response time for the request this stream is a response for</param>
-        /// <returns></returns>
-        protected async Task<CallResult<T>> DeserializeAsync<T>(Stream stream, JsonSerializer? serializer = null, int? requestId = null, long? elapsedMilliseconds = null)
-        {
-            if (serializer == null)
-                serializer = defaultSerializer;
-
-            try
-            {
-                // Let the reader keep the stream open so we're able to seek if needed. The calling method will close the stream.
-                using var reader = new StreamReader(stream, Encoding.UTF8, false, 512, true);
-
-                // If we have to output the original json data or output the data into the logging we'll have to read to full response
-                // in order to log/return the json data
-                if (OutputOriginalData || log.Level <= LogLevel.Debug)
-                {
-                    var data = await reader.ReadToEndAsync().ConfigureAwait(false);
-                    log.Write(LogLevel.Debug, $"{(requestId != null ? $"[{requestId}] ": "")}Response received{(elapsedMilliseconds != null ? $" in {elapsedMilliseconds}" : " ")}ms: {data}");
-                    var result = Deserialize<T>(data, null, serializer, requestId);
-                    if(OutputOriginalData)
-                        result.OriginalData = data;
-                    return result;
-                }
-                
-                // If we don't have to keep track of the original json data we can use the JsonTextReader to deserialize the stream directly
-                // into the desired object, which has increased performance over first reading the string value into memory and deserializing from that
-                using var jsonReader = new JsonTextReader(reader);
-                return new CallResult<T>(serializer.Deserialize<T>(jsonReader), null);
-            }
-            catch (JsonReaderException jre)
-            {
-                string data;
-                if (stream.CanSeek)
-                {
-                    // If we can seek the stream rewind it so we can retrieve the original data that was sent
-                    stream.Seek(0, SeekOrigin.Begin);
-                    data = await ReadStreamAsync(stream).ConfigureAwait(false);
-                }
-                else
-                    data = "[Data only available in Debug LogLevel]";
-                log.Write(LogLevel.Error, $"{(requestId != null ? $"[{requestId}] " : "")}Deserialize JsonReaderException: {jre.Message}, Path: {jre.Path}, LineNumber: {jre.LineNumber}, LinePosition: {jre.LinePosition}, data: {data}");
-                return new CallResult<T>(default, new DeserializeError($"Deserialize JsonReaderException: {jre.Message}, Path: {jre.Path}, LineNumber: {jre.LineNumber}, LinePosition: {jre.LinePosition}", data));
-            }
-            catch (JsonSerializationException jse)
-            {
-                string data;
-                if (stream.CanSeek)
-                {
-                    stream.Seek(0, SeekOrigin.Begin);
-                    data = await ReadStreamAsync(stream).ConfigureAwait(false);
-                }
-                else
-                    data = "[Data only available in Debug LogLevel]";
-
-                log.Write(LogLevel.Error, $"{(requestId != null ? $"[{requestId}] " : "")}Deserialize JsonSerializationException: {jse.Message}, data: {data}");
-                return new CallResult<T>(default, new DeserializeError($"Deserialize JsonSerializationException: {jse.Message}", data));
-            }
-            catch (Exception ex)
-            {
-                string data;
-                if (stream.CanSeek) { 
-                    stream.Seek(0, SeekOrigin.Begin);
-                    data = await ReadStreamAsync(stream).ConfigureAwait(false);
-                }
-                else
-                    data = "[Data only available in Debug LogLevel]";
-
-                var exceptionInfo = ex.ToLogString();
-                log.Write(LogLevel.Error, $"{(requestId != null ? $"[{requestId}] " : "")}Deserialize Unknown Exception: {exceptionInfo}, data: {data}");
-                return new CallResult<T>(default, new DeserializeError($"Deserialize Unknown Exception: {exceptionInfo}", data));
-            }
-        }
-
-        private async Task<string> ReadStreamAsync(Stream stream)
-        { 
-            using var reader = new StreamReader(stream, Encoding.UTF8, false, 512, true);
-            return await reader.ReadToEndAsync().ConfigureAwait(false);
-        }
-
-        private void CheckObject(Type type, JObject obj, int? requestId = null)
-        {
-            if (type == null)
-                return;
-
-            if (type.GetCustomAttribute<JsonConverterAttribute>(true) != null)
-                // If type has a custom JsonConverter we assume this will handle property mapping
-                return;
-
-            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<,>))
-                return;
-
-            if (!obj.HasValues && type != typeof(object))
-            {
-                log.Write(LogLevel.Warning, $"{(requestId != null ? $"[{requestId}] " : "")}Expected `{type.Name}`, but received object was empty");
-                return;
-            }
-
-            var isDif = false;
-            var properties = new List<string>();
-            var props = type.GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.FlattenHierarchy);
-            foreach (var prop in props)
-            {
-                var attr = prop.GetCustomAttributes(typeof(JsonPropertyAttribute), false).FirstOrDefault();
-                var ignore = prop.GetCustomAttributes(typeof(JsonIgnoreAttribute), false).FirstOrDefault();
-                if (ignore != null)
-                    continue;
-
-                var propertyName = ((JsonPropertyAttribute?) attr)?.PropertyName;
-                properties.Add(propertyName ?? prop.Name);
-            }
-            foreach (var token in obj)
-            {
-                var d = properties.FirstOrDefault(p => p == token.Key);
-                if (d == null)
-                {
-                    d = properties.SingleOrDefault(p => string.Equals(p, token.Key, StringComparison.CurrentCultureIgnoreCase));
-                    if (d == null)
-                    {
-                        if (!(type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<,>)))
-                        {
-                            log.Write(LogLevel.Warning, $"{(requestId != null ? $"[{requestId}] " : "")}Local object doesn't have property `{token.Key}` expected in type `{type.Name}`");
-                            isDif = true;
-                        }
-                        continue;
-                    }
-                }
-
-                properties.Remove(d);
-
-                var propType = GetProperty(d, props)?.PropertyType;
-                if (propType == null || token.Value == null)
-                    continue;
-                if (!IsSimple(propType) && propType != typeof(DateTime))
-                {
-                    if (propType.IsArray && token.Value.HasValues && ((JArray)token.Value).Any() && ((JArray)token.Value)[0] is JObject)
-                        CheckObject(propType.GetElementType()!, (JObject)token.Value[0]!, requestId);
-                    else if (token.Value is JObject o)
-                        CheckObject(propType, o, requestId);
-                }
-            }
-
-            foreach (var prop in properties)
-            {
-                var propInfo = props.First(p => p.Name == prop ||
-                    ((JsonPropertyAttribute)p.GetCustomAttributes(typeof(JsonPropertyAttribute), false).FirstOrDefault())?.PropertyName == prop);
-                var optional = propInfo.GetCustomAttributes(typeof(JsonOptionalPropertyAttribute), false).FirstOrDefault();
-                if (optional != null)
-                    continue;
-
-                isDif = true;
-                log.Write(LogLevel.Warning, $"{(requestId != null ? $"[{requestId}] " : "")}Local object has property `{prop}` but was not found in received object of type `{type.Name}`");
-            }
-
-            if (isDif)
-                log.Write(LogLevel.Debug, $"{(requestId != null ? $"[{ requestId}] " : "")}Returned data: " + obj);
-        }
-
-        private static PropertyInfo? GetProperty(string name, IEnumerable<PropertyInfo> props)
-        {
-            foreach (var prop in props)
-            {
-                var attr = prop.GetCustomAttributes(typeof(JsonPropertyAttribute), false).FirstOrDefault();
-                if (attr == null)
-                {
-                    if (string.Equals(prop.Name, name, StringComparison.CurrentCultureIgnoreCase))
-                        return prop;
-                }
-                else
-                {
-                    if (((JsonPropertyAttribute)attr).PropertyName == name)
-                        return prop;
-                }
-            }
-            return null;
-        }
-
-        private static bool IsSimple(Type type)
-        {
-            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
-            {
-                // nullable type, check if the nested type is simple.
-                return IsSimple(type.GetGenericArguments()[0]);
-            }
-            return type.IsPrimitive
-                   || type.IsEnum
-                   || type == typeof(string)
-                   || type == typeof(decimal);
-        }
-
-        /// <summary>
-        /// Generate a new unique id. The id is staticly stored so it is guarenteed to be unique across different client instances
-        /// </summary>
-        /// <returns></returns>
-        protected int NextId()
-        {
-            lock (idLock)
-            {
-                lastId += 1;
-                return lastId;
-            }
-        }
-
-        /// <summary>
-        /// Fill parameters in a path. Parameters are specified by '{}' and should be specified in occuring sequence
-        /// </summary>
-        /// <param name="path">The total path string</param>
-        /// <param name="values">The values to fill</param>
-        /// <returns></returns>
-        protected static string FillPathParameter(string path, params string[] values)
-        {
-            foreach (var value in values)
-            {
-                var index = path.IndexOf("{}", StringComparison.Ordinal);
-                if (index >= 0)
-                {
-                    path = path.Remove(index, 2);
-                    path = path.Insert(index, value);
-                }
-            }
-            return path;
-        }
-
-        /// <summary>
-        /// Dispose
-        /// </summary>
-        public virtual void Dispose()
-        {
-            authProvider?.Credentials?.Dispose();
-            log.Write(LogLevel.Debug, "Disposing exchange client");
-        }
-    }
-}

CryptoExchange.Net/Caching/MemoryCache.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Concurrent;
+
+namespace CryptoExchange.Net.Caching
+{
+    internal class MemoryCache
+    {
+        private readonly ConcurrentDictionary<string, CacheItem> _cache = new ConcurrentDictionary<string, CacheItem>();
+
+        /// <summary>
+        /// Add a new cache entry. Will override an existing entry if it already exists
+        /// </summary>
+        /// <param name="key">The key identifier</param>
+        /// <param name="value">Cache value</param>
+        public void Add(string key, object value)
+        {
+            var cacheItem = new CacheItem(DateTime.UtcNow, value);
+            _cache.AddOrUpdate(key, cacheItem, (key, val1) => cacheItem);
+        }
+
+        /// <summary>
+        /// Get a cached value
+        /// </summary>
+        /// <param name="key">The key identifier</param>
+        /// <param name="maxAge">The max age of the cached entry</param>
+        /// <returns>Cached value if it was in cache</returns>
+        public object? Get(string key, TimeSpan maxAge)
+        {
+            _cache.TryGetValue(key, out CacheItem value);
+            if (value == null)
+                return null;
+
+            if (DateTime.UtcNow - value.CacheTime > maxAge)
+            {
+                _cache.TryRemove(key, out _);
+                return null;
+            }
+
+            return value.Value;
+        }
+
+        private class CacheItem
+        {
+            public DateTime CacheTime { get; }
+            public object Value { get; }
+
+            public CacheItem(DateTime cacheTime, object value)
+            {
+                CacheTime = cacheTime;
+                Value = value;
+            }
+        }
+    }
+}

CryptoExchange.Net/Clients/BaseApiClient.cs

@@ -0,0 +1,104 @@
+using System;
+using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.SharedApis;
+using Microsoft.Extensions.Logging;
+
+namespace CryptoExchange.Net.Clients
+{
+    /// <summary>
+    /// Base API for all API clients
+    /// </summary>
+    public abstract class BaseApiClient : IDisposable, IBaseApiClient
+    {
+        /// <summary>
+        /// Logger
+        /// </summary>
+        protected ILogger _logger;
+
+        /// <summary>
+        /// If we are disposing
+        /// </summary>
+        protected bool _disposing;
+
+        /// <summary>
+        /// The authentication provider for this API client. (null if no credentials are set)
+        /// </summary>
+        public AuthenticationProvider? AuthenticationProvider { get; private set; }
+
+        /// <summary>
+        /// The environment this client communicates to
+        /// </summary>
+        public string BaseAddress { get; }
+
+        /// <summary>
+        /// Output the original string data along with the deserialized object
+        /// </summary>
+        public bool OutputOriginalData { get; }
+
+        /// <summary>
+        /// Whether or not API credentials have been configured for this client. Does not check the credentials are actually valid.
+        /// </summary>
+        public bool Authenticated => ApiOptions.ApiCredentials != null || ClientOptions.ApiCredentials != null;
+
+        /// <summary>
+        /// Api options
+        /// </summary>
+        public ApiOptions ApiOptions { get; }
+
+        /// <summary>
+        /// Client Options
+        /// </summary>
+        public ExchangeOptions ClientOptions { get; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="logger">Logger</param>
+        /// <param name="outputOriginalData">Should data from this client include the orginal data in the call result</param>
+        /// <param name="baseAddress">Base address for this API client</param>
+        /// <param name="apiCredentials">Api credentials</param>
+        /// <param name="clientOptions">Client options</param>
+        /// <param name="apiOptions">Api options</param>
+        protected BaseApiClient(ILogger logger, bool outputOriginalData, ApiCredentials? apiCredentials, string baseAddress, ExchangeOptions clientOptions, ApiOptions apiOptions)
+        {
+            _logger = logger;
+
+            ClientOptions = clientOptions;
+            ApiOptions = apiOptions;
+            OutputOriginalData = outputOriginalData;
+            BaseAddress = baseAddress;
+
+            if (apiCredentials != null)
+                AuthenticationProvider = CreateAuthenticationProvider(apiCredentials.Copy());
+        }
+
+        /// <summary>
+        /// Create an AuthenticationProvider implementation instance based on the provided credentials
+        /// </summary>
+        /// <param name="credentials"></param>
+        /// <returns></returns>
+        protected abstract AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials);
+
+        /// <inheritdoc />
+        public abstract string FormatSymbol(string baseAsset, string quoteAsset, TradingMode tradingMode, DateTime? deliverDate = null);
+
+        /// <inheritdoc />
+        public void SetApiCredentials<T>(T credentials) where T : ApiCredentials
+        {
+            ApiOptions.ApiCredentials = credentials;
+            if (credentials != null)
+                AuthenticationProvider = CreateAuthenticationProvider(credentials.Copy());
+        }
+
+        /// <summary>
+        /// Dispose
+        /// </summary>
+        public virtual void Dispose()
+        {
+            _disposing = true;
+        }
+    }
+}

CryptoExchange.Net/Clients/BaseClient.cs

@@ -0,0 +1,132 @@
+using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Objects.Options;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using System;
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.Clients
+{
+    /// <summary>
+    /// The base for all clients, websocket client and rest client
+    /// </summary>
+    public abstract class BaseClient : IDisposable
+    {
+        /// <summary>
+        /// Version of the CryptoExchange.Net base library
+        /// </summary>
+        public Version CryptoExchangeLibVersion { get; } = typeof(BaseClient).Assembly.GetName().Version;
+
+        /// <summary>
+        /// Version of the client implementation
+        /// </summary>
+        public Version ExchangeLibVersion
+        { 
+            get
+            {
+               lock(_versionLock)
+                {
+                    if (_exchangeVersion == null)
+                        _exchangeVersion = GetType().Assembly.GetName().Version;
+
+                    return _exchangeVersion;
+                }
+            }
+        }
+
+        /// <summary>
+        /// The name of the API the client is for
+        /// </summary>
+        public string Exchange { get; }
+
+        /// <summary>
+        /// Api clients in this client
+        /// </summary>
+        internal List<BaseApiClient> ApiClients { get; } = new List<BaseApiClient>();
+
+        /// <summary>
+        /// The log object
+        /// </summary>
+        protected internal ILogger _logger;
+
+        private object _versionLock = new object();
+        private Version _exchangeVersion;
+
+        /// <summary>
+        /// Provided client options
+        /// </summary>
+        public ExchangeOptions ClientOptions { get; private set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="logger">Logger</param>
+        /// <param name="exchange">The name of the exchange this client is for</param>
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        protected BaseClient(ILoggerFactory? logger, string exchange)
+#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            _logger = logger?.CreateLogger(exchange) ?? NullLoggerFactory.Instance.CreateLogger(exchange);
+
+            Exchange = exchange;
+        }
+
+        /// <summary>
+        /// Initialize the client with the specified options
+        /// </summary>
+        /// <param name="options"></param>
+        /// <exception cref="ArgumentNullException"></exception>
+        protected virtual void Initialize(ExchangeOptions options)
+        {
+            if (options == null)
+                throw new ArgumentNullException(nameof(options));
+
+            ClientOptions = options;
+            _logger.Log(LogLevel.Trace, $"Client configuration: {options}, CryptoExchange.Net: v{CryptoExchangeLibVersion}, {Exchange}.Net: v{ExchangeLibVersion}");
+        }
+
+        /// <summary>
+        /// Set the API credentials for this client. All Api clients in this client will use the new credentials, regardless of earlier set options.
+        /// </summary>
+        /// <param name="credentials">The credentials to set</param>
+        protected virtual void SetApiCredentials<T>(T credentials) where T : ApiCredentials
+        {
+            foreach (var apiClient in ApiClients)
+                apiClient.SetApiCredentials(credentials);
+        }
+
+        /// <summary>
+        /// Register an API client
+        /// </summary>
+        /// <param name="apiClient">The client</param>
+        protected T AddApiClient<T>(T apiClient) where T : BaseApiClient
+        {
+            if (ClientOptions == null)
+                throw new InvalidOperationException("Client should have called Initialize before adding API clients");
+
+            _logger.Log(LogLevel.Trace, $"  {apiClient.GetType().Name}, base address: {apiClient.BaseAddress}");
+            ApiClients.Add(apiClient);
+            return apiClient;
+        }
+
+        /// <summary>
+        /// Apply the options delegate to a new options instance
+        /// </summary>
+        protected static T ApplyOptionsDelegate<T>(Action<T>? del) where T: new()
+        {
+            var opts = new T();
+            del?.Invoke(opts);
+            return opts;
+        }
+
+        /// <summary>
+        /// Dispose
+        /// </summary>
+        public virtual void Dispose()
+        {
+            _logger.Log(LogLevel.Debug, "Disposing client");
+            foreach (var client in ApiClients)
+                client.Dispose();
+        }
+    }
+}

CryptoExchange.Net/Clients/BaseRestClient.cs

@@ -0,0 +1,24 @@
+using System.Linq;
+using CryptoExchange.Net.Interfaces;
+using Microsoft.Extensions.Logging;
+
+namespace CryptoExchange.Net.Clients
+{
+    /// <summary>
+    /// Base rest client
+    /// </summary>
+    public abstract class BaseRestClient : BaseClient, IRestClient
+    {
+        /// <inheritdoc />
+        public int TotalRequestsMade => ApiClients.OfType<RestApiClient>().Sum(s => s.TotalRequestsMade);
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="loggerFactory">Logger factory</param>
+        /// <param name="name">The name of the API this client is for</param>
+        protected BaseRestClient(ILoggerFactory? loggerFactory, string name) : base(loggerFactory, name)
+        {
+        }
+    }
+}

CryptoExchange.Net/Clients/BaseSocketClient.cs

@@ -0,0 +1,126 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Logging.Extensions;
+using CryptoExchange.Net.Objects.Sockets;
+using Microsoft.Extensions.Logging;
+
+namespace CryptoExchange.Net.Clients
+{
+    /// <summary>
+    /// Base for socket client implementations
+    /// </summary>
+    public abstract class BaseSocketClient : BaseClient, ISocketClient
+    {
+        #region fields
+
+        /// <summary>
+        /// If client is disposing
+        /// </summary>
+        protected bool _disposing;
+
+        /// <inheritdoc />
+        public int CurrentConnections => ApiClients.OfType<SocketApiClient>().Sum(c => c.CurrentConnections);
+        /// <inheritdoc />
+        public int CurrentSubscriptions => ApiClients.OfType<SocketApiClient>().Sum(s => s.CurrentSubscriptions);
+        /// <inheritdoc />
+        public double IncomingKbps => ApiClients.OfType<SocketApiClient>().Sum(s => s.IncomingKbps);
+        #endregion
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="logger">Logger</param>
+        /// <param name="exchange">The name of the exchange this client is for</param>
+        protected BaseSocketClient(ILoggerFactory? logger, string exchange) : base(logger, exchange)
+        {
+        }
+
+        /// <summary>
+        /// Unsubscribe an update subscription
+        /// </summary>
+        /// <param name="subscriptionId">The id of the subscription to unsubscribe</param>
+        /// <returns></returns>
+        public virtual async Task UnsubscribeAsync(int subscriptionId)
+        {
+            foreach (var socket in ApiClients.OfType<SocketApiClient>())
+            {
+                var result = await socket.UnsubscribeAsync(subscriptionId).ConfigureAwait(false);
+                if (result)
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Unsubscribe an update subscription
+        /// </summary>
+        /// <param name="subscription">The subscription to unsubscribe</param>
+        /// <returns></returns>
+        public virtual async Task UnsubscribeAsync(UpdateSubscription subscription)
+        {
+            if (subscription == null)
+                throw new ArgumentNullException(nameof(subscription));
+
+            _logger.UnsubscribingSubscription(subscription.SocketId, subscription.Id);
+            await subscription.CloseAsync().ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Unsubscribe all subscriptions
+        /// </summary>
+        /// <returns></returns>
+        public virtual async Task UnsubscribeAllAsync()
+        {
+            var tasks = new List<Task>();
+            foreach (var client in ApiClients.OfType<SocketApiClient>())
+                tasks.Add(client.UnsubscribeAllAsync());
+
+            await Task.WhenAll(tasks.ToArray()).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Reconnect all connections
+        /// </summary>
+        /// <returns></returns>
+        public virtual async Task ReconnectAsync()
+        {
+            _logger.ReconnectingAllConnections(CurrentConnections);
+            var tasks = new List<Task>();
+            foreach (var client in ApiClients.OfType<SocketApiClient>())
+            {
+                tasks.Add(client.ReconnectAsync());
+            }
+            await Task.WhenAll(tasks.ToArray()).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Log the current state of connections and subscriptions
+        /// </summary>
+        public string GetSubscriptionsState()
+        {
+            var result = new StringBuilder();
+            foreach (var client in ApiClients.OfType<SocketApiClient>().Where(c => c.CurrentSubscriptions > 0))
+            {
+                result.AppendLine(client.GetSubscriptionsState());
+            }
+            return result.ToString();
+        }
+
+        /// <summary>
+        /// Returns the state of all socket api clients
+        /// </summary>
+        /// <returns></returns>
+        public List<SocketApiClient.SocketApiClientState> GetSocketApiClientStates()
+        {
+            var result = new List<SocketApiClient.SocketApiClientState>();
+            foreach (var client in ApiClients.OfType<SocketApiClient>())
+            {
+                result.Add(client.GetState());
+            }
+            return result;
+        }
+    }
+}

CryptoExchange.Net/Clients/CryptoBaseClient.cs

@@ -0,0 +1,67 @@
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.Clients
+{
+    /// <summary>
+    /// Base crypto client
+    /// </summary>
+    public class CryptoBaseClient : IDisposable
+    {
+        private Dictionary<Type, object> _serviceCache = new Dictionary<Type, object>();
+
+        /// <summary>
+        /// Service provider
+        /// </summary>
+        protected readonly IServiceProvider? _serviceProvider;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public CryptoBaseClient() { }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="serviceProvider"></param>
+        public CryptoBaseClient(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+            _serviceCache = new Dictionary<Type, object>();
+        }
+
+        /// <summary>
+        /// Try get a client by type for the service collection
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public T TryGet<T>(Func<T> createFunc)
+        {
+            var type = typeof(T);
+            if (_serviceCache.TryGetValue(type, out var value))
+                return (T)value;
+
+            if (_serviceProvider == null)
+            {
+                // Create with default options
+                var createResult = createFunc();
+                _serviceCache.Add(typeof(T), createResult!);
+                return createResult;
+            }
+
+            var result = _serviceProvider.GetService<T>() 
+                ?? throw new InvalidOperationException($"No service was found for {typeof(T).Name}, make sure the exchange is registered in dependency injection with the `services.Add[Exchange]()` method");
+            _serviceCache.Add(type, result!);
+            return result;
+        }
+
+        /// <summary>
+        /// Dispose
+        /// </summary>
+        public void Dispose()
+        {
+            _serviceCache.Clear();
+        }
+    }
+}

CryptoExchange.Net/Clients/CryptoRestClient.cs

@@ -0,0 +1,47 @@
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Interfaces.CommonClients;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace CryptoExchange.Net.Clients
+{
+    /// <inheritdoc />
+    public class CryptoRestClient : CryptoBaseClient, ICryptoRestClient
+    {
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public CryptoRestClient()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="serviceProvider"></param>
+        public CryptoRestClient(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
+
+        /// <summary>
+        /// Get a list of the registered ISpotClient implementations
+        /// </summary>
+        /// <returns></returns>
+        public IEnumerable<ISpotClient> GetSpotClients()
+        {
+            if (_serviceProvider == null)
+                return new List<ISpotClient>();
+
+            return _serviceProvider.GetServices<ISpotClient>().ToList();
+        }
+
+        /// <summary>
+        /// Get an ISpotClient implementation by exchange name
+        /// </summary>
+        /// <param name="exchangeName"></param>
+        /// <returns></returns>
+        public ISpotClient? SpotClient(string exchangeName) => _serviceProvider?.GetServices<ISpotClient>()?.SingleOrDefault(s => s.ExchangeName.Equals(exchangeName, StringComparison.InvariantCultureIgnoreCase));
+    }
+}

CryptoExchange.Net/Clients/CryptoSocketClient.cs

@@ -0,0 +1,24 @@
+using CryptoExchange.Net.Interfaces;
+using System;
+
+namespace CryptoExchange.Net.Clients
+{
+    /// <inheritdoc />
+    public class CryptoSocketClient : CryptoBaseClient, ICryptoSocketClient
+    {
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public CryptoSocketClient()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="serviceProvider"></param>
+        public CryptoSocketClient(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
+    }
+}

CryptoExchange.Net/Clients/SocketApiClient.cs

@@ -0,0 +1,828 @@
+using CryptoExchange.Net.Converters.JsonNet;
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Logging.Extensions;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using CryptoExchange.Net.Sockets;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.WebSockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+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();
+
+        /// <summary>
+        /// List of socket connections currently connecting/connected
+        /// </summary>
+        protected internal ConcurrentDictionary<int, SocketConnection> socketConnections = new();
+
+        /// <summary>
+        /// Semaphore used while creating sockets
+        /// </summary>
+        protected internal readonly SemaphoreSlim semaphoreSlim = new(1);
+
+        /// <summary>
+        /// Keep alive interval for websocket connection
+        /// </summary>
+        protected TimeSpan KeepAliveInterval { get; set; } = TimeSpan.FromSeconds(10);
+
+        /// <summary>
+        /// Handlers for data from the socket which doesn't need to be forwarded to the caller. Ping or welcome messages for example.
+        /// </summary>
+        protected List<SystemSubscription> systemSubscriptions = new();
+
+        /// <summary>
+        /// If a message is received on the socket which is not handled by a handler this boolean determines whether this logs an error message
+        /// </summary>
+        protected internal bool UnhandledMessageExpected { get; set; }
+
+        /// <summary>
+        /// The rate limiters 
+        /// </summary>
+        protected internal IRateLimitGate? RateLimiter { get; set; }
+
+        /// <summary>
+        /// The max size a websocket message size can be
+        /// </summary>
+        protected internal int? MessageSendSizeLimit { get; set; }
+
+        /// <summary>
+        /// Periodic task registrations
+        /// </summary>
+        protected List<PeriodicTaskRegistration> PeriodicTaskRegistrations { get; set; } = new List<PeriodicTaskRegistration>();
+
+        /// <summary>
+        /// List of address to keep an alive connection to
+        /// </summary>
+        protected List<DedicatedConnectionConfig> DedicatedConnectionConfigs { get; set; } = new List<DedicatedConnectionConfig>();
+
+        /// <summary>
+        /// Whether to allow multiple subscriptions with the same topic on the same connection
+        /// </summary>
+        protected bool AllowTopicsOnTheSameConnection { get; set; } = true;
+
+        /// <inheritdoc />
+        public double IncomingKbps
+        {
+            get
+            {
+                if (!socketConnections.Any())
+                    return 0;
+
+                return socketConnections.Sum(s => s.Value.IncomingKbps);
+            }
+        }
+
+        /// <inheritdoc />
+        public int CurrentConnections => socketConnections.Count;
+
+        /// <inheritdoc />
+        public int CurrentSubscriptions
+        {
+            get
+            {
+                if (!socketConnections.Any())
+                    return 0;
+
+                return socketConnections.Sum(s => s.Value.UserSubscriptionCount);
+            }
+        }
+
+        /// <inheritdoc />
+        public new SocketExchangeOptions ClientOptions => (SocketExchangeOptions)base.ClientOptions;
+
+        /// <inheritdoc />
+        public new SocketApiOptions ApiOptions => (SocketApiOptions)base.ApiOptions;
+
+        #endregion
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="logger">log</param>
+        /// <param name="options">Client options</param>
+        /// <param name="baseAddress">Base address for this API client</param>
+        /// <param name="apiOptions">The Api client options</param>
+        public SocketApiClient(ILogger logger, string baseAddress, SocketExchangeOptions options, SocketApiOptions apiOptions)
+            : base(logger,
+                  apiOptions.OutputOriginalData ?? options.OutputOriginalData,
+                  apiOptions.ApiCredentials ?? options.ApiCredentials,
+                  baseAddress,
+                  options,
+                  apiOptions)
+        {
+        }
+
+        /// <summary>
+        /// Create a message accessor instance
+        /// </summary>
+        /// <returns></returns>
+        protected internal virtual IByteMessageAccessor CreateAccessor() => new JsonNetByteMessageAccessor();
+
+        /// <summary>
+        /// Create a serializer instance
+        /// </summary>
+        /// <returns></returns>
+        protected internal virtual IMessageSerializer CreateSerializer() => new JsonNetMessageSerializer();
+
+        /// <summary>
+        /// Keep an open connection to this url
+        /// </summary>
+        /// <param name="url"></param>
+        /// <param name="auth"></param>
+        protected virtual void SetDedicatedConnection(string url, bool auth)
+        {
+            DedicatedConnectionConfigs.Add(new DedicatedConnectionConfig() { SocketAddress = url, Authenticated = auth });
+        }
+
+        /// <summary>
+        /// Add a query to periodically send on each connection
+        /// </summary>
+        /// <param name="identifier"></param>
+        /// <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<CallResult>? callback)
+        {
+            PeriodicTaskRegistrations.Add(new PeriodicTaskRegistration
+            {
+                Identifier = identifier,
+                Callback = callback,
+                Interval = interval,
+                QueryDelegate = queryDelegate
+            });
+        }
+
+        /// <summary>
+        /// Connect to an url and listen for data on the BaseAddress
+        /// </summary>
+        /// <param name="subscription">The subscription</param>
+        /// <param name="ct">Cancellation token for closing this subscription</param>
+        /// <returns></returns>
+        protected virtual Task<CallResult<UpdateSubscription>> SubscribeAsync(Subscription subscription, CancellationToken ct)
+        {
+            return SubscribeAsync(BaseAddress, subscription, ct);
+        }
+
+        /// <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="ct">Cancellation token for closing this subscription</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult<UpdateSubscription>> SubscribeAsync(string url, Subscription subscription, CancellationToken ct)
+        {
+            if (_disposing)
+                return new CallResult<UpdateSubscription>(new InvalidOperationError("Client disposed, can't subscribe"));
+
+            if (subscription.Authenticated && AuthenticationProvider == null)
+            {
+                _logger.LogWarning("Failed to subscribe, private subscription but no API credentials set");
+                return new CallResult<UpdateSubscription>(new NoApiCredentialsError());
+            }
+
+            SocketConnection socketConnection;
+            var released = false;
+            // 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)
+            {
+                return new CallResult<UpdateSubscription>(new CancellationRequestedError());
+            }
+
+            try
+            {
+                while (true)
+                {
+                    // Get a new or existing socket connection
+                    var socketResult = await GetSocketConnection(url, subscription.Authenticated, false, subscription.Topic).ConfigureAwait(false);
+                    if (!socketResult)
+                        return socketResult.As<UpdateSubscription>(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, subscription.Authenticated).ConfigureAwait(false);
+                    if (!connectResult)
+                        return new CallResult<UpdateSubscription>(connectResult.Error!);
+
+                    break;
+                }
+            }
+            finally
+            {
+                if (!released)
+                    semaphoreSlim.Release();
+            }
+
+            if (socketConnection.PausedActivity)
+            {
+                _logger.HasBeenPausedCantSubscribeAtThisMoment(socketConnection.SocketId);
+                return new CallResult<UpdateSubscription>(new ServerError("Socket is paused"));
+            }
+
+            var waitEvent = new AsyncResetEvent(false);
+            var subQuery = subscription.GetSubQuery(socketConnection);
+            if (subQuery != null)
+            {
+                // Send the request and wait for answer
+                var subResult = await socketConnection.SendAndWaitQueryAsync(subQuery, waitEvent).ConfigureAwait(false);
+                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.Confirmed = true;
+            if (ct != default)
+            {
+                subscription.CancellationTokenRegistration = ct.Register(async () =>
+                {
+                    _logger.CancellationTokenSetClosingSubscription(socketConnection.SocketId, subscription.Id);
+                    await socketConnection.CloseAsync(subscription).ConfigureAwait(false);
+                }, false);
+            }
+
+            waitEvent?.Set();
+            _logger.SubscriptionCompletedSuccessfully(socketConnection.SocketId, subscription.Id);
+            return new CallResult<UpdateSubscription>(new UpdateSubscription(socketConnection, subscription));
+        }
+
+        /// <summary>
+        /// Send a query on a socket connection to the BaseAddress and wait for the response
+        /// </summary>
+        /// <typeparam name="THandlerResponse">Expected result type</typeparam>
+        /// <typeparam name="TServerResponse">The type returned to the caller</typeparam>
+        /// <param name="query">The query</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <returns></returns>
+        protected virtual Task<CallResult<THandlerResponse>> QueryAsync<TServerResponse, THandlerResponse>(Query<TServerResponse, THandlerResponse> query, CancellationToken ct = default)
+        {
+            return QueryAsync(BaseAddress, query, ct);
+        }
+
+        /// <summary>
+        /// Send a query on a socket connection and wait for the response
+        /// </summary>
+        /// <typeparam name="THandlerResponse">Expected result type</typeparam>
+        /// <typeparam name="TServerResponse">The type returned to the caller</typeparam>
+        /// <param name="url">The url for the request</param>
+        /// <param name="query">The query</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult<THandlerResponse>> QueryAsync<TServerResponse, THandlerResponse>(string url, Query<TServerResponse, THandlerResponse> query, CancellationToken ct = default)
+        {
+            if (_disposing)
+                return new CallResult<THandlerResponse>(new InvalidOperationError("Client disposed, can't query"));
+
+            if (ct.IsCancellationRequested)
+                return new CallResult<THandlerResponse>(new CancellationRequestedError());
+
+            SocketConnection socketConnection;
+            var released = false;
+            await semaphoreSlim.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                var socketResult = await GetSocketConnection(url, query.Authenticated, true).ConfigureAwait(false);
+                if (!socketResult)
+                    return socketResult.As<THandlerResponse>(default);
+
+                socketConnection = socketResult.Data;
+
+                if (ClientOptions.SocketSubscriptionsCombineTarget == 1)
+                {
+                    // Can release early when only a single sub per connection
+                    semaphoreSlim.Release();
+                    released = true;
+                }
+
+                var connectResult = await ConnectIfNeededAsync(socketConnection, query.Authenticated).ConfigureAwait(false);
+                if (!connectResult)
+                    return new CallResult<THandlerResponse>(connectResult.Error!);
+            }
+            finally
+            {
+                if (!released)
+                    semaphoreSlim.Release();
+            }
+
+            if (socketConnection.PausedActivity)
+            {
+                _logger.HasBeenPausedCantSendQueryAtThisMoment(socketConnection.SocketId);
+                return new CallResult<THandlerResponse>(new ServerError("Socket is paused"));
+            }
+
+            if (ct.IsCancellationRequested)
+                return new CallResult<THandlerResponse>(new CancellationRequestedError());
+
+            return await socketConnection.SendAndWaitQueryAsync(query, null, ct).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Checks if a socket needs to be connected and does so if needed. Also authenticates on the socket if needed
+        /// </summary>
+        /// <param name="socket">The connection to check</param>
+        /// <param name="authenticated">Whether the socket should authenticated</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult> ConnectIfNeededAsync(SocketConnection socket, bool authenticated)
+        {
+            if (socket.Connected)
+                return new CallResult(null);
+
+            var connectResult = await ConnectSocketAsync(socket).ConfigureAwait(false);
+            if (!connectResult)
+                return connectResult;
+
+            if (ClientOptions.DelayAfterConnect != TimeSpan.Zero)
+                await Task.Delay(ClientOptions.DelayAfterConnect).ConfigureAwait(false);
+
+            if (!authenticated || socket.Authenticated)
+                return new CallResult(null);
+
+            var result = await AuthenticateSocketAsync(socket).ConfigureAwait(false);
+            if (!result)
+                await socket.CloseAsync().ConfigureAwait(false);
+
+            return result;
+        }
+
+        /// <summary>
+        /// Authenticate a socket connection
+        /// </summary>
+        /// <param name="socket">Socket to authenticate</param>
+        /// <returns></returns>
+        public virtual async Task<CallResult> AuthenticateSocketAsync(SocketConnection socket)
+        {
+            if (AuthenticationProvider == null)
+                return new CallResult(new NoApiCredentialsError());
+
+            _logger.AttemptingToAuthenticate(socket.SocketId);
+            var authRequest = await GetAuthenticationRequestAsync(socket).ConfigureAwait(false);
+            if (authRequest != null)
+            {
+                var result = await socket.SendAndWaitQueryAsync(authRequest).ConfigureAwait(false);
+
+                if (!result)
+                {
+                    _logger.AuthenticationFailed(socket.SocketId);
+                    if (socket.Connected)
+                        await socket.CloseAsync().ConfigureAwait(false);
+
+                    result.Error!.Message = "Authentication failed: " + result.Error.Message;
+                    return new CallResult(result.Error)!;
+                }
+            }
+
+            _logger.Authenticated(socket.SocketId);
+            socket.Authenticated = true;
+            return new CallResult(null);
+        }
+
+        /// <summary>
+        /// 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();
+
+        /// <summary>
+        /// Adds a system subscription. Used for example to reply to ping requests
+        /// </summary>
+        /// <param name="systemSubscription">The subscription</param>
+        protected void AddSystemSubscription(SystemSubscription systemSubscription)
+        {
+            systemSubscriptions.Add(systemSubscription);
+            foreach (var connection in socketConnections.Values)
+                connection.AddSubscription(systemSubscription);
+        }
+
+        /// <summary>
+        /// Get the url to connect to (defaults to BaseAddress form the client options)
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="authentication"></param>
+        /// <returns></returns>
+        protected virtual Task<CallResult<string?>> GetConnectionUrlAsync(string address, bool authentication)
+        {
+            return Task.FromResult(new CallResult<string?>(address));
+        }
+
+        /// <summary>
+        /// Get the url to reconnect to after losing a connection
+        /// </summary>
+        /// <param name="connection"></param>
+        /// <returns></returns>
+        protected internal virtual Task<Uri?> GetReconnectUriAsync(SocketConnection connection)
+        {
+            return Task.FromResult<Uri?>(connection.ConnectionUri);
+        }
+
+        /// <summary>
+        /// Update the subscription when the connection is restored after disconnecting. Can be used to update an authentication token for example.
+        /// </summary>
+        /// <param name="subscription">The subscription</param>
+        /// <returns></returns>
+        protected internal virtual Task<CallResult> RevitalizeRequestAsync(Subscription subscription)
+        {
+            return Task.FromResult(new CallResult(null));
+        }
+
+        /// <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="authenticated">Whether the socket should be authenticated</param>
+        /// <param name="dedicatedRequestConnection">Whether a dedicated request connection should be returned</param>
+        /// <param name="topic">The subscription topic, can be provided when multiple of the same topics are not allowed on a connection</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult<SocketConnection>> GetSocketConnection(string address, bool authenticated, bool dedicatedRequestConnection, string? topic = null)
+        {
+            var socketQuery = socketConnections.Where(s => (s.Value.Status == SocketConnection.SocketStatus.None || s.Value.Status == SocketConnection.SocketStatus.Connected)
+                                                      && s.Value.Tag.TrimEnd('/') == address.TrimEnd('/')
+                                                      && s.Value.ApiClient.GetType() == GetType()
+                                                      && (s.Value.Authenticated == authenticated || !authenticated)
+                                                      && (AllowTopicsOnTheSameConnection || !s.Value.Topics.Contains(topic))
+                                                      && s.Value.Connected);
+
+            SocketConnection connection;
+            if (!dedicatedRequestConnection)
+            {
+                connection = socketQuery.Where(s => !s.Value.DedicatedRequestConnection.IsDedicatedRequestConnection).OrderBy(s => s.Value.UserSubscriptionCount).FirstOrDefault().Value;
+            }
+            else
+            {
+                connection = socketQuery.Where(s => s.Value.DedicatedRequestConnection.IsDedicatedRequestConnection).FirstOrDefault().Value;
+                if (connection != null && !connection.DedicatedRequestConnection.Authenticated)
+                    // Mark dedicated request connection as authenticated if the request is authenticated
+                    connection.DedicatedRequestConnection.Authenticated = authenticated;
+            }
+
+            if (connection != null)
+            {
+                if (connection.UserSubscriptionCount < ClientOptions.SocketSubscriptionsCombineTarget || socketConnections.Count >= (ApiOptions.MaxSocketConnections ?? ClientOptions.MaxSocketConnections) && socketConnections.All(s => s.Value.UserSubscriptionCount >= ClientOptions.SocketSubscriptionsCombineTarget))
+                    // Use existing socket if it has less than target connections OR it has the least connections and we can't make new
+                    return new CallResult<SocketConnection>(connection);
+            }
+
+            var connectionAddress = await GetConnectionUrlAsync(address, authenticated).ConfigureAwait(false);
+            if (!connectionAddress)
+            {
+                _logger.FailedToDetermineConnectionUrl(connectionAddress.Error?.ToString());
+                return connectionAddress.As<SocketConnection>(null);
+            }
+
+            if (connectionAddress.Data != address)
+                _logger.ConnectionAddressSetTo(connectionAddress.Data!);
+
+            // Create new socket
+            var socket = CreateSocket(connectionAddress.Data!);
+            var socketConnection = new SocketConnection(_logger, this, socket, address);
+            socketConnection.UnhandledMessage += HandleUnhandledMessage;
+            socketConnection.ConnectRateLimitedAsync += HandleConnectRateLimitedAsync;
+            if (dedicatedRequestConnection)
+            {
+                socketConnection.DedicatedRequestConnection = new DedicatedConnectionState
+                {
+                    IsDedicatedRequestConnection = dedicatedRequestConnection,
+                    Authenticated = authenticated
+                };
+            }
+
+            foreach (var ptg in PeriodicTaskRegistrations)
+                socketConnection.QueryPeriodic(ptg.Identifier, ptg.Interval, ptg.QueryDelegate, ptg.Callback);
+
+            foreach (var systemSubscription in systemSubscriptions)
+                socketConnection.AddSubscription(systemSubscription);
+
+            return new CallResult<SocketConnection>(socketConnection);
+        }
+
+        /// <summary>
+        /// Process an unhandled message
+        /// </summary>
+        /// <param name="message">The message that wasn't processed</param>
+        protected virtual void HandleUnhandledMessage(IMessageAccessor message)
+        {
+        }
+
+        /// <summary>
+        /// Process connect rate limited
+        /// </summary>
+        protected async virtual Task HandleConnectRateLimitedAsync()
+        {
+            if (ClientOptions.RateLimiterEnabled && RateLimiter is not null && ClientOptions.ConnectDelayAfterRateLimited is not null)
+            {
+                var retryAfter = DateTime.UtcNow.Add(ClientOptions.ConnectDelayAfterRateLimited.Value);
+                _logger.AddingRetryAfterGuard(retryAfter);
+                await RateLimiter.SetRetryAfterGuardAsync(retryAfter, RateLimiting.RateLimitItemType.Connection).ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Connect a socket
+        /// </summary>
+        /// <param name="socketConnection">The socket to connect</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult> ConnectSocketAsync(SocketConnection socketConnection)
+        {
+            var connectResult = await socketConnection.ConnectAsync().ConfigureAwait(false);
+            if (connectResult)
+            {
+                socketConnections.TryAdd(socketConnection.SocketId, socketConnection);
+                return connectResult;
+            }
+
+            socketConnection.Dispose();
+            return connectResult;
+        }
+
+        /// <summary>
+        /// Get parameters for the websocket connection
+        /// </summary>
+        /// <param name="address">The address to connect to</param>
+        /// <returns></returns>
+        protected virtual WebSocketParameters GetWebSocketParameters(string address)
+            => new(new Uri(address), ClientOptions.ReconnectPolicy)
+            {
+                KeepAliveInterval = KeepAliveInterval,
+                ReconnectInterval = ClientOptions.ReconnectInterval,
+                RateLimiter = ClientOptions.RateLimiterEnabled ? RateLimiter : null,
+                RateLimitingBehaviour = ClientOptions.RateLimitingBehaviour,
+                Proxy = ClientOptions.Proxy,
+                Timeout = ApiOptions.SocketNoDataTimeout ?? ClientOptions.SocketNoDataTimeout
+            };
+
+        /// <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>
+        /// <param name="subscriptionId">The id of the subscription to unsubscribe</param>
+        /// <returns></returns>
+        public virtual async Task<bool> UnsubscribeAsync(int subscriptionId)
+        {
+            Subscription? subscription = null;
+            SocketConnection? connection = null;
+            foreach (var socket in socketConnections.Values.ToList())
+            {
+                subscription = socket.GetSubscription(subscriptionId);
+                if (subscription != null)
+                {
+                    connection = socket;
+                    break;
+                }
+            }
+
+            if (subscription == null || connection == null)
+                return false;
+
+            _logger.UnsubscribingSubscription(connection.SocketId, subscriptionId);
+            await connection.CloseAsync(subscription).ConfigureAwait(false);
+            return true;
+        }
+
+        /// <summary>
+        /// Unsubscribe an update subscription
+        /// </summary>
+        /// <param name="subscription">The subscription to unsubscribe</param>
+        /// <returns></returns>
+        public virtual async Task UnsubscribeAsync(UpdateSubscription subscription)
+        {
+            if (subscription == null)
+                throw new ArgumentNullException(nameof(subscription));
+
+            _logger.UnsubscribingSubscription(subscription.SocketId, subscription.Id);
+            await subscription.CloseAsync().ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Unsubscribe all subscriptions
+        /// </summary>
+        /// <returns></returns>
+        public virtual async Task UnsubscribeAllAsync()
+        {
+            var sum = socketConnections.Sum(s => s.Value.UserSubscriptionCount);
+            if (sum == 0)
+                return;
+
+            _logger.UnsubscribingAll(socketConnections.Sum(s => s.Value.UserSubscriptionCount));
+            var tasks = new List<Task>();
+            {
+                var socketList = socketConnections.Values;
+                foreach (var connection in socketList.Where(s => !s.DedicatedRequestConnection.IsDedicatedRequestConnection))
+                    tasks.Add(connection.CloseAsync());
+            }
+
+            await Task.WhenAll(tasks.ToArray()).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Reconnect all connections
+        /// </summary>
+        /// <returns></returns>
+        public virtual async Task ReconnectAsync()
+        {
+            _logger.ReconnectingAllConnections(socketConnections.Count);
+            var tasks = new List<Task>();
+            {
+                var socketList = socketConnections.Values;
+                foreach (var sub in socketList)
+                    tasks.Add(sub.TriggerReconnectAsync());
+            }
+
+            await Task.WhenAll(tasks.ToArray()).ConfigureAwait(false);
+        }
+
+        /// <inheritdoc />
+        public virtual async Task<CallResult> PrepareConnectionsAsync()
+        {
+            foreach (var item in DedicatedConnectionConfigs)
+            {
+                var socketResult = await GetSocketConnection(item.SocketAddress, item.Authenticated, true).ConfigureAwait(false);
+                if (!socketResult)
+                    return socketResult.AsDataless();
+
+                var connectResult = await ConnectIfNeededAsync(socketResult.Data, item.Authenticated).ConfigureAwait(false);
+                if (!connectResult)
+                    return new CallResult(connectResult.Error!);
+            }
+
+            return new CallResult(null);
+        }
+
+        /// <summary>
+        /// Log the current state of connections and subscriptions
+        /// </summary>
+        public string GetSubscriptionsState(bool includeSubDetails = true)
+        {
+            return GetState(includeSubDetails).ToString();
+        }
+
+        /// <summary>
+        /// Gets the state of the client
+        /// </summary>
+        /// <param name="includeSubDetails">True to get details for each subscription</param>
+        /// <returns></returns>
+        public SocketApiClientState GetState(bool includeSubDetails = true)
+        {
+            var connectionStates = new List<SocketConnection.SocketConnectionState>();
+            foreach (var socketIdAndConnection in socketConnections)
+            {
+                SocketConnection connection = socketIdAndConnection.Value;
+                SocketConnection.SocketConnectionState connectionState = connection.GetState(includeSubDetails);
+                connectionStates.Add(connectionState);
+            }
+
+            return new SocketApiClientState(socketConnections.Count, CurrentSubscriptions, IncomingKbps, connectionStates);
+        }
+
+        /// <summary>
+        /// Get the current state of the client
+        /// </summary>
+        /// <param name="Connections">Number of sockets for this client</param>
+        /// <param name="Subscriptions">Total number of subscriptions</param>
+        /// <param name="DownloadSpeed">Total download speed</param>
+        /// <param name="ConnectionStates">State of each socket connection</param>
+        public record SocketApiClientState(
+            int Connections,
+            int Subscriptions,
+            double DownloadSpeed,
+            List<SocketConnection.SocketConnectionState> ConnectionStates)
+        {
+            /// <summary>
+            /// Print the state of the client
+            /// </summary>
+            /// <param name="sb"></param>
+            /// <returns></returns>
+            protected virtual bool PrintMembers(StringBuilder sb)
+            {
+                sb.AppendLine();
+                sb.AppendLine($"\tTotal connections: {Connections}");
+                sb.AppendLine($"\tTotal subscriptions: {Subscriptions}");
+                sb.AppendLine($"\tDownload speed: {DownloadSpeed} kbps");
+                sb.AppendLine($"\tConnections:");
+                ConnectionStates.ForEach(cs =>
+                {
+                    sb.AppendLine($"\t\tId: {cs.Id}");
+                    sb.AppendLine($"\t\tAddress: {cs.Address}");
+                    sb.AppendLine($"\t\tTotal subscriptions: {cs.Subscriptions}");
+                    sb.AppendLine($"\t\tStatus: {cs.Status}");
+                    sb.AppendLine($"\t\tAuthenticated: {cs.Authenticated}");
+                    sb.AppendLine($"\t\tDownload speed: {cs.DownloadSpeed} kbps");
+                    sb.AppendLine($"\t\tPending queries: {cs.PendingQueries}");
+                    if (cs.SubscriptionStates?.Count > 0)
+                    {
+                        sb.AppendLine($"\t\tSubscriptions:");
+                        cs.SubscriptionStates.ForEach(subState =>
+                        {
+                            sb.AppendLine($"\t\t\tId: {subState.Id}");
+                            sb.AppendLine($"\t\t\tConfirmed: {subState.Confirmed}");
+                            sb.AppendLine($"\t\t\tInvocations: {subState.Invocations}");
+                            sb.AppendLine($"\t\t\tIdentifiers: [{string.Join(",", subState.Identifiers)}]");
+                        });
+                    }
+                });
+
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Dispose the client
+        /// </summary>
+        public override void Dispose()
+        {
+            _disposing = true;
+            var tasks = new List<Task>();
+            {
+                var socketList = socketConnections.Values.Where(x => x.UserSubscriptionCount > 0 || x.Connected);
+                if (socketList.Any())
+                    _logger.DisposingSocketClient();
+
+                foreach (var connection in socketList)
+                {
+                    tasks.Add(connection.CloseAsync());
+                }
+            }
+
+            semaphoreSlim?.Dispose();
+            base.Dispose();
+        }
+
+        /// <summary>
+        /// Get the listener identifier for the message
+        /// </summary>
+        /// <param name="messageAccessor"></param>
+        /// <returns></returns>
+        public abstract string? GetListenerIdentifier(IMessageAccessor messageAccessor);
+
+        /// <summary>
+        /// Preprocess a stream message
+        /// </summary>
+        /// <param name="connection"></param>
+        /// <param name="type"></param>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        public virtual ReadOnlyMemory<byte> PreprocessStreamMessage(SocketConnection connection, WebSocketMessageType type, ReadOnlyMemory<byte> data) => data;
+    }
+}

CryptoExchange.Net/CommonObjects/Balance.cs

@@ -0,0 +1,21 @@
+namespace CryptoExchange.Net.CommonObjects
+{
+    /// <summary>
+    /// Balance data
+    /// </summary>
+    public class Balance: BaseCommonObject
+    {
+        /// <summary>
+        /// The asset name
+        /// </summary>
+        public string Asset { get; set;  } = string.Empty;
+        /// <summary>
+        /// Quantity available
+        /// </summary>
+        public decimal? Available { get; set; }
+        /// <summary>
+        /// Total quantity
+        /// </summary>
+        public decimal? Total { get; set;  }
+    }
+}

CryptoExchange.Net/CommonObjects/BaseComonObject.cs

@@ -0,0 +1,13 @@
+namespace CryptoExchange.Net.CommonObjects
+{
+    /// <summary>
+    /// Base class for common objects
+    /// </summary>
+    public class BaseCommonObject
+    {
+        /// <summary>
+        /// The source object the data is derived from
+        /// </summary>
+        public object SourceObject { get; set; } = null!;
+    }
+}

CryptoExchange.Net/CommonObjects/Enums.cs

@@ -0,0 +1,73 @@
+namespace CryptoExchange.Net.CommonObjects
+{
+    /// <summary>
+    /// Order type
+    /// </summary>
+    public enum CommonOrderType
+    {
+        /// <summary>
+        /// Limit type
+        /// </summary>
+        Limit,
+        /// <summary>
+        /// Market type
+        /// </summary>
+        Market,
+        /// <summary>
+        /// Other order type
+        /// </summary>
+        Other
+    }
+
+    /// <summary>
+    /// Order side
+    /// </summary>
+    public enum CommonOrderSide
+    {
+        /// <summary>
+        /// Buy order
+        /// </summary>
+        Buy,
+        /// <summary>
+        /// Sell order
+        /// </summary>
+        Sell
+    }
+    /// <summary>
+    /// Order status
+    /// </summary>
+    public enum CommonOrderStatus
+    {
+        /// <summary>
+        /// placed and not fully filled order
+        /// </summary>
+        Active,
+        /// <summary>
+        /// canceled order
+        /// </summary>
+        Canceled,
+        /// <summary>
+        /// filled order
+        /// </summary>
+        Filled
+    }
+    
+    /// <summary>
+    /// Position side
+    /// </summary>
+    public enum CommonPositionSide
+    {
+        /// <summary>
+        /// Long position
+        /// </summary>
+        Long,
+        /// <summary>
+        /// Short position
+        /// </summary>
+        Short,
+        /// <summary>
+        /// Both
+        /// </summary>
+        Both
+    }
+}

CryptoExchange.Net/CommonObjects/Kline.cs

@@ -0,0 +1,35 @@
+using System;
+
+namespace CryptoExchange.Net.CommonObjects
+{
+    /// <summary>
+    /// Kline data
+    /// </summary>
+    public class Kline: BaseCommonObject
+    {
+        /// <summary>
+        /// Opening time of the kline
+        /// </summary>
+        public DateTime OpenTime { get; set; }
+        /// <summary>
+        /// Price at the open time
+        /// </summary>
+        public decimal? OpenPrice { get; set; }
+        /// <summary>
+        /// Highest price of the kline
+        /// </summary>
+        public decimal? HighPrice { get; set; }
+        /// <summary>
+        /// Lowest price of the kline
+        /// </summary>
+        public decimal? LowPrice { get; set; }
+        /// <summary>
+        /// Close price of the kline
+        /// </summary>
+        public decimal? ClosePrice { get; set; }
+        /// <summary>
+        /// Volume of the kline
+        /// </summary>
+        public decimal? Volume { get; set; }
+    }
+}

CryptoExchange.Net/CommonObjects/Order.cs

@@ -0,0 +1,47 @@
+using System;
+
+namespace CryptoExchange.Net.CommonObjects
+{
+    /// <summary>
+    /// Order data
+    /// </summary>
+    public class Order: BaseCommonObject
+    {
+        /// <summary>
+        /// Id of the order
+        /// </summary>
+        public string Id { get; set; } = string.Empty;
+        /// <summary>
+        /// Symbol of the order
+        /// </summary>
+        public string Symbol { get; set; } = string.Empty;
+        /// <summary>
+        /// Price of the order
+        /// </summary>
+        public decimal? Price { get; set; }
+        /// <summary>
+        /// Quantity of the order
+        /// </summary>
+        public decimal? Quantity { get; set; }
+        /// <summary>
+        /// The quantity of the order which has been filled
+        /// </summary>
+        public decimal? QuantityFilled { get; set; }
+        /// <summary>
+        /// Status of the order
+        /// </summary>
+        public CommonOrderStatus Status { get; set; }
+        /// <summary>
+        /// Side of the order
+        /// </summary>
+        public CommonOrderSide Side { get; set; }
+        /// <summary>
+        /// Type of the order
+        /// </summary>
+        public CommonOrderType Type { get; set; }
+        /// <summary>
+        /// Order time
+        /// </summary>
+        public DateTime Timestamp { get; set; }
+    }
+}

CryptoExchange.Net/CommonObjects/OrderBook.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.CommonObjects
+{
+    /// <summary>
+    /// Order book data
+    /// </summary>
+    public class OrderBook: BaseCommonObject
+    {
+        /// <summary>
+        /// List of bids
+        /// </summary>
+        public IEnumerable<OrderBookEntry> Bids { get; set; } = Array.Empty<OrderBookEntry>();
+        /// <summary>
+        /// List of asks
+        /// </summary>
+        public IEnumerable<OrderBookEntry> Asks { get; set; } = Array.Empty<OrderBookEntry>();
+    }
+}

CryptoExchange.Net/CommonObjects/OrderBookEntry.cs

@@ -0,0 +1,17 @@
+namespace CryptoExchange.Net.CommonObjects
+{
+    /// <summary>
+    /// Order book entry
+    /// </summary>
+    public class OrderBookEntry
+    {
+        /// <summary>
+        /// Quantity of the entry
+        /// </summary>
+        public decimal Quantity { get; set; }
+        /// <summary>
+        /// Price of the entry
+        /// </summary>
+        public decimal Price { get; set; }
+    }
+}

CryptoExchange.Net/CommonObjects/OrderId.cs

@@ -0,0 +1,13 @@
+namespace CryptoExchange.Net.CommonObjects
+{
+    /// <summary>
+    /// Id of an order
+    /// </summary>
+    public class OrderId: BaseCommonObject
+    {
+        /// <summary>
+        /// Id of an order
+        /// </summary>
+        public string Id { get; set; } = string.Empty;
+    }
+}

CryptoExchange.Net/CommonObjects/Position.cs

@@ -0,0 +1,65 @@
+namespace CryptoExchange.Net.CommonObjects
+{
+    /// <summary>
+    /// Position data
+    /// </summary>
+    public class Position: BaseCommonObject
+    {
+        /// <summary>
+        /// Id of the position
+        /// </summary>
+        public string? Id { get; set; }
+        /// <summary>
+        /// Symbol of the position
+        /// </summary>
+        public string Symbol { get; set; } = string.Empty;
+        /// <summary>
+        /// Leverage
+        /// </summary>
+        public decimal Leverage { get; set; }
+        /// <summary>
+        /// Position quantity
+        /// </summary>
+        public decimal Quantity { get; set; }
+        /// <summary>
+        /// Entry price
+        /// </summary>
+        public decimal? EntryPrice { get; set; }
+        /// <summary>
+        /// Liquidation price
+        /// </summary>
+        public decimal? LiquidationPrice { get; set; }
+        /// <summary>
+        /// Unrealized profit and loss
+        /// </summary>
+        public decimal? UnrealizedPnl { get; set; }
+        /// <summary>
+        /// Realized profit and loss
+        /// </summary>
+        public decimal? RealizedPnl { get; set; }
+        /// <summary>
+        /// Mark price
+        /// </summary>
+        public decimal? MarkPrice { get; set; }
+        /// <summary>
+        /// Auto adding margin
+        /// </summary>
+        public bool? AutoMargin { get; set; }
+        /// <summary>
+        /// Position margin
+        /// </summary>
+        public decimal? PositionMargin { get; set; }
+        /// <summary>
+        /// Position side
+        /// </summary>
+        public CommonPositionSide? Side { get; set; }
+        /// <summary>
+        /// Is isolated
+        /// </summary>
+        public bool? Isolated { get; set; }
+        /// <summary>
+        /// Maintenance margin
+        /// </summary>
+        public decimal? MaintananceMargin { get; set; }
+    }
+}

CryptoExchange.Net/CommonObjects/Symbol.cs

@@ -0,0 +1,33 @@
+namespace CryptoExchange.Net.CommonObjects
+{
+    /// <summary>
+    /// Symbol data
+    /// </summary>
+    public class Symbol: BaseCommonObject
+    {
+        /// <summary>
+        /// Name of the symbol
+        /// </summary>
+        public string Name { get; set; } = string.Empty;
+        /// <summary>
+        /// Minimal quantity of an order
+        /// </summary>
+        public decimal? MinTradeQuantity { get; set; }
+        /// <summary>
+        /// Step with which the quantity should increase
+        /// </summary>
+        public decimal? QuantityStep { get; set; } 
+        /// <summary>
+        /// step with which the price should increase
+        /// </summary>
+        public decimal? PriceStep { get; set; } 
+        /// <summary>
+        /// The max amount of decimals for quantity
+        /// </summary>
+        public int? QuantityDecimals { get; set; } 
+        /// <summary>
+        /// The max amount of decimal for price
+        /// </summary>
+        public int? PriceDecimals { get; set; } 
+    }
+}

CryptoExchange.Net/CommonObjects/Ticker.cs

@@ -0,0 +1,33 @@
+namespace CryptoExchange.Net.CommonObjects
+{
+    /// <summary>
+    /// Ticker data
+    /// </summary>
+    public class Ticker: BaseCommonObject
+    {
+        /// <summary>
+        /// Symbol
+        /// </summary>
+        public string Symbol { get; set; } = string.Empty;
+        /// <summary>
+        /// Price 24 hours ago
+        /// </summary>
+        public decimal? Price24H { get; set; }
+        /// <summary>
+        /// Last trade price
+        /// </summary>
+        public decimal? LastPrice { get; set; }
+        /// <summary>
+        /// 24 hour low price
+        /// </summary>
+        public decimal? LowPrice { get; set; }
+        /// <summary>
+        /// 24 hour high price
+        /// </summary>
+        public decimal? HighPrice { get; set; }
+        /// <summary>
+        /// 24 hour volume
+        /// </summary>
+        public decimal? Volume { get; set; }
+    }
+}

CryptoExchange.Net/CommonObjects/Trade.cs

@@ -0,0 +1,50 @@
+using System;
+
+namespace CryptoExchange.Net.CommonObjects
+{
+    /// <summary>
+    /// Trade data
+    /// </summary>
+    public class Trade: BaseCommonObject
+    {
+        /// <summary>
+        /// Symbol of the trade
+        /// </summary>
+        public string Symbol { get; set; } = string.Empty;
+        /// <summary>
+        /// Price of the trade
+        /// </summary>
+        public decimal Price { get; set; }
+        /// <summary>
+        /// Quantity of the trade
+        /// </summary>
+        public decimal Quantity { get; set; }
+        /// <summary>
+        /// Timestamp of the trade
+        /// </summary>
+        public DateTime Timestamp { get; set; }
+    }
+
+    /// <summary>
+    /// User trade info
+    /// </summary>
+    public class UserTrade: Trade
+    {
+        /// <summary>
+        /// Id of the trade
+        /// </summary>
+        public string Id { get; set; } = string.Empty;
+        /// <summary>
+        /// Order id of the trade
+        /// </summary>
+        public string? OrderId { get; set; }
+        /// <summary>
+        /// Fee of the trade
+        /// </summary>
+        public decimal? Fee { get; set; }
+        /// <summary>
+        /// The asset the fee is paid in
+        /// </summary>
+        public string? FeeAsset { get; set; }
+    }
+}

CryptoExchange.Net/Converters/ArrayPropertyAttribute.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace CryptoExchange.Net.Converters
+{
+    /// <summary>
+    /// Mark property as an index in the array
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property)]
+    public class ArrayPropertyAttribute : Attribute
+    {
+        /// <summary>
+        /// The index in the array
+        /// </summary>
+        public int Index { get; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="index"></param>
+        public ArrayPropertyAttribute(int index)
+        {
+            Index = index;
+        }
+    }
+}

CryptoExchange.Net/Converters/JsonNet/ArrayConverter.cs

@@ -8,7 +8,7 @@ using CryptoExchange.Net.Attributes;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
-namespace CryptoExchange.Net.Converters
+namespace CryptoExchange.Net.Converters.JsonNet
 {
     /// <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
@@ -16,8 +16,8 @@ namespace CryptoExchange.Net.Converters
     /// </summary>
     public class ArrayConverter : JsonConverter
     {
-        private static readonly ConcurrentDictionary<(MemberInfo, Type), Attribute> attributeByMemberInfoAndTypeCache = new ConcurrentDictionary<(MemberInfo, Type), Attribute>();
+        private static readonly ConcurrentDictionary<(MemberInfo, Type), Attribute> _attributeByMemberInfoAndTypeCache = new ConcurrentDictionary<(MemberInfo, Type), Attribute>();
-        private static readonly ConcurrentDictionary<(Type, Type), Attribute> attributeByTypeAndTypeCache = new ConcurrentDictionary<(Type, Type), Attribute>();
+        private static readonly ConcurrentDictionary<(Type, Type), Attribute> _attributeByTypeAndTypeCache = new ConcurrentDictionary<(Type, Type), Attribute>();
 
         /// <inheritdoc />
         public override bool CanConvert(Type objectType)
@@ -28,6 +28,9 @@ namespace CryptoExchange.Net.Converters
         /// <inheritdoc />
         public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
         {
+            if (reader.TokenType == JsonToken.Null)
+                return null;
+
             if (objectType == typeof(JToken))
                 return JToken.Load(reader);
 
@@ -36,7 +39,7 @@ namespace CryptoExchange.Net.Converters
             return ParseObject(arr, result, objectType);
         }
 
-        private static object? ParseObject(JArray arr, object result, Type objectType)
+        private static object ParseObject(JArray arr, object result, Type objectType)
         {
             foreach (var property in objectType.GetProperties())
             {
@@ -63,8 +66,8 @@ namespace CryptoExchange.Net.Converters
                         var arrayResult = (IList)Activator.CreateInstance(property.PropertyType, new [] { innerArray.Count });
                         foreach (var obj in innerArray)
                         {
-                            var innerObj = Activator.CreateInstance(objType);
+                            var innerObj = Activator.CreateInstance(objType!);
-                            arrayResult[count] = ParseObject((JArray)obj, innerObj, objType);
+                            arrayResult[count] = ParseObject((JArray)obj, innerObj, objType!);
                             count++;
                         }
                         property.SetValue(result, arrayResult);
@@ -72,8 +75,8 @@ namespace CryptoExchange.Net.Converters
                     else
                     {
                         var arrayResult = (IList)Activator.CreateInstance(property.PropertyType, new [] { 1 });
-                        var innerObj = Activator.CreateInstance(objType);
+                        var innerObj = Activator.CreateInstance(objType!);
-                        arrayResult[0] = ParseObject(innerArray, innerObj, objType);
+                        arrayResult[0] = ParseObject(innerArray, innerObj, objType!);
                         property.SetValue(result, arrayResult);
                     }
                     continue;
@@ -97,18 +100,30 @@ namespace CryptoExchange.Net.Converters
                 }
 
                 if (value != null && property.PropertyType.IsInstanceOfType(value))
+                {
                     property.SetValue(result, value);
+                }
                 else
                 {
                     if (value is JToken token)
+                    {
                         if (token.Type == JTokenType.Null)
                             value = null;
 
-                    if ((property.PropertyType == typeof(decimal)
+                        if (token.Type == JTokenType.Float)
-                     || property.PropertyType == typeof(decimal?))
+                            value = token.Value<decimal>();
-                     && (value != null && value.ToString().Contains("e")))
+                    }
+
+                    if (value is decimal)
                     {
-                        if (decimal.TryParse(value.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out var dec))
+                        property.SetValue(result, value);
+                    }
+                    else if ((property.PropertyType == typeof(decimal)
+                     || property.PropertyType == typeof(decimal?))
+                     && (value != null && value.ToString().IndexOf("e", StringComparison.OrdinalIgnoreCase) >= 0))
+                    {
+                        var v = value.ToString();
+                        if (decimal.TryParse(v, NumberStyles.Float, CultureInfo.InvariantCulture, out var dec))
                             property.SetValue(result, dec);
                     }
                     else
@@ -172,29 +187,9 @@ namespace CryptoExchange.Net.Converters
         }
 
         private static T? GetCustomAttribute<T>(MemberInfo memberInfo) where T : Attribute =>
-            (T?)attributeByMemberInfoAndTypeCache.GetOrAdd((memberInfo, typeof(T)), tuple => memberInfo.GetCustomAttribute(typeof(T)));
+            (T?)_attributeByMemberInfoAndTypeCache.GetOrAdd((memberInfo, typeof(T)), tuple => memberInfo.GetCustomAttribute(typeof(T)));
 
         private static T? GetCustomAttribute<T>(Type type) where T : Attribute =>
-            (T?)attributeByTypeAndTypeCache.GetOrAdd((type, typeof(T)), tuple => type.GetCustomAttribute(typeof(T)));
+            (T?)_attributeByTypeAndTypeCache.GetOrAdd((type, typeof(T)), tuple => type.GetCustomAttribute(typeof(T)));
-    }
-
-    /// <summary>
-    /// Mark property as an index in the array
-    /// </summary>
-    public class ArrayPropertyAttribute: Attribute
-    {
-        /// <summary>
-        /// The index in the array
-        /// </summary>
-        public int Index { get; }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="index"></param>
-        public ArrayPropertyAttribute(int index)
-        {
-            Index = index;
-        }
     }
 }

CryptoExchange.Net/Converters/JsonNet/BaseConverter.cs

@@ -4,7 +4,7 @@ using System.Diagnostics;
 using System.Linq;
 using Newtonsoft.Json;
 
-namespace CryptoExchange.Net.Converters
+namespace CryptoExchange.Net.Converters.JsonNet
 {
     /// <summary>
     /// Base class for enum converters
@@ -16,7 +16,7 @@ namespace CryptoExchange.Net.Converters
         /// The enum->string mapping
         /// </summary>
         protected abstract List<KeyValuePair<T, string>> Mapping { get; }
-        private readonly bool quotes;
+        private readonly bool _quotes;
         
         /// <summary>
         /// ctor
@@ -24,14 +24,14 @@ namespace CryptoExchange.Net.Converters
         /// <param name="useQuotes"></param>
         protected BaseConverter(bool useQuotes)
         {
-            quotes = useQuotes;
+            _quotes = useQuotes;
         }
 
         /// <inheritdoc />
         public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
         {
             var stringValue = value == null? null: GetValue((T) value);
-            if (quotes)
+            if (_quotes)
                 writer.WriteValue(stringValue);
             else
                 writer.WriteRawValue(stringValue);
@@ -43,9 +43,13 @@ namespace CryptoExchange.Net.Converters
             if (reader.Value == null)
                 return null;
 
-            if (!GetValue(reader.Value.ToString(), out var result))
+            var stringValue = reader.Value.ToString();
+            if (string.IsNullOrWhiteSpace(stringValue))
+                return null;
+
+            if (!GetValue(stringValue, out var result))
             {
-                Debug.WriteLine($"Cannot map enum. Type: {typeof(T)}, Value: {reader.Value}");
+                Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Cannot map enum value. EnumType: {typeof(T)}, Value: {reader.Value}, Known values: {string.Join(", ", Mapping.Select(m => m.Value))}. If you think {reader.Value} should added please open an issue on the Github repo");
                 return null;
             }
 
@@ -71,7 +75,7 @@ namespace CryptoExchange.Net.Converters
 
         private bool GetValue(string value, out T result)
         {
-            //check for exact match first, then if not found fallback to a case insensitive match 
+            // Check for exact match first, then if not found fallback to a case insensitive match 
             var mapping = Mapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCulture));
             if(mapping.Equals(default(KeyValuePair<T, string>)))
                 mapping = Mapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCultureIgnoreCase));

CryptoExchange.Net/Converters/JsonNet/BigDecimalConverter.cs

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

CryptoExchange.Net/Converters/JsonNet/BoolConverter.cs

@@ -0,0 +1,80 @@
+using System;
+using Newtonsoft.Json;
+
+namespace CryptoExchange.Net.Converters.JsonNet
+{
+    /// <summary>
+    /// Boolean converter with support for "0"/"1" (strings)
+    /// </summary>
+    public class BoolConverter : JsonConverter
+    {
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// <c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            if (Nullable.GetUnderlyingType(objectType) != null)
+                return Nullable.GetUnderlyingType(objectType) == typeof(bool);
+            return objectType == typeof(bool);
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>
+        /// The object value.
+        /// </returns>
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            var value = reader.Value?.ToString().ToLower().Trim();
+            if (value == null || value == "")
+            {
+                if (Nullable.GetUnderlyingType(objectType) != null)
+                    return null;
+
+                return false;
+            }
+
+            switch (value)
+            {
+                case "true":
+                case "yes":
+                case "y":
+                case "1":
+                case "on":
+                    return true;
+                case "false":
+                case "no":
+                case "n":
+                case "0":
+                case "off":
+                case "-1":
+                    return false;
+            }
+
+            // If we reach here, we're pretty much going to throw an error so let's let Json.NET throw it's pretty-fied error message.
+            return new JsonSerializer().Deserialize(reader, objectType);
+        }
+
+        /// <summary>
+        /// Specifies that this converter will not participate in writing results.
+        /// </summary>
+        public override bool CanWrite { get { return false; } }
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="T:Newtonsoft.Json.JsonWriter"/> to write to.</param><param name="value">The value.</param><param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+        }
+    }
+}

CryptoExchange.Net/Converters/JsonNet/DateTimeConverter.cs

@@ -0,0 +1,240 @@
+using Newtonsoft.Json;
+using System;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+
+namespace CryptoExchange.Net.Converters.JsonNet
+{
+    /// <summary>
+    /// Datetime converter. Supports converting from string/long/double to DateTime and back. Numbers are assumed to be the time since 1970-01-01.
+    /// </summary>
+    public class DateTimeConverter: JsonConverter
+    {
+        private static readonly DateTime _epoch = new(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        private const long _ticksPerSecond = TimeSpan.TicksPerMillisecond * 1000;
+        private const decimal _ticksPerMicrosecond = TimeSpan.TicksPerMillisecond / 1000;
+        private const decimal _ticksPerNanosecond = TimeSpan.TicksPerMillisecond / 1000m / 1000;
+
+        /// <inheritdoc />
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(DateTime) || objectType == typeof(DateTime?);
+        }
+
+        /// <inheritdoc />
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            if (reader.Value == null)
+            {
+                if (objectType == typeof(DateTime))
+                    return default(DateTime);
+
+                return null;
+            }
+
+            if(reader.TokenType is JsonToken.Integer)
+            {
+                var longValue = (long)reader.Value;
+                if (longValue == 0 || longValue == -1)
+                    return objectType == typeof(DateTime) ? default(DateTime): null;
+
+                return ParseFromLong(longValue);
+            }
+            else if (reader.TokenType is JsonToken.Float)
+            {
+                var doubleValue = (double)reader.Value;
+                if (doubleValue == 0 || doubleValue == -1)
+                    return objectType == typeof(DateTime) ? default(DateTime) : null;
+
+                if (doubleValue < 19999999999)
+                    return ConvertFromSeconds(doubleValue);
+                
+                return ConvertFromMilliseconds(doubleValue);
+            }
+            else if(reader.TokenType is JsonToken.String)
+            {
+                var stringValue = (string)reader.Value;
+                if (string.IsNullOrWhiteSpace(stringValue)
+                    || stringValue == "-1"
+                    || (double.TryParse(stringValue, out var doubleVal) && doubleVal == 0))
+                {
+                    return objectType == typeof(DateTime) ? default(DateTime) : null;
+                }
+
+                return ParseFromString(stringValue);
+            }
+            else if(reader.TokenType == JsonToken.Date)
+            {
+                return (DateTime)reader.Value;
+            }
+            else
+            {
+                Trace.WriteLine("{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + reader.Value);
+                return default;
+            }
+        }
+
+        /// <summary>
+        /// Parse a long value to datetime
+        /// </summary>
+        /// <param name="longValue"></param>
+        /// <returns></returns>
+        public static DateTime ParseFromLong(long longValue)
+        {
+            if (longValue < 19999999999)
+                return ConvertFromSeconds(longValue);
+            if (longValue < 19999999999999)
+                return ConvertFromMilliseconds(longValue);
+            if (longValue < 19999999999999999)
+                return ConvertFromMicroseconds(longValue);
+
+            return ConvertFromNanoseconds(longValue);
+        }
+
+        /// <summary>
+        /// Parse a string value to datetime
+        /// </summary>
+        /// <param name="stringValue"></param>
+        /// <returns></returns>
+        public static DateTime ParseFromString(string stringValue)
+        {
+            if (stringValue.Length == 12 && stringValue.StartsWith("202"))
+            {
+                // Parse 202303261200 format
+                if (!int.TryParse(stringValue.Substring(0, 4), out var year)
+                    || !int.TryParse(stringValue.Substring(4, 2), out var month)
+                    || !int.TryParse(stringValue.Substring(6, 2), out var day)
+                    || !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);
+                    return default;
+                }
+                return new DateTime(year, month, day, hour, minute, 0, DateTimeKind.Utc);
+            }
+
+            if (stringValue.Length == 8)
+            {
+                // Parse 20211103 format
+                if (!int.TryParse(stringValue.Substring(0, 4), out var year)
+                    || !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);
+                    return default;
+                }
+                return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
+            }
+
+            if (stringValue.Length == 6)
+            {
+                // Parse 211103 format
+                if (!int.TryParse(stringValue.Substring(0, 2), out var year)
+                    || !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);
+                    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))
+            {
+                // Parse 1637745563.000 format
+                if (doubleValue < 19999999999)
+                    return ConvertFromSeconds(doubleValue);
+                if (doubleValue < 19999999999999)
+                    return ConvertFromMilliseconds((long)doubleValue);
+                if (doubleValue < 19999999999999999)
+                    return ConvertFromMicroseconds((long)doubleValue);
+
+                return ConvertFromNanoseconds((long)doubleValue);
+            }
+
+            if (stringValue.Length == 10)
+            {
+                // Parse 2021-11-03 format
+                var values = stringValue.Split('-');
+                if (!int.TryParse(values[0], out var year)
+                    || !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);
+                    return default;
+                }
+
+                return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
+            }
+
+            return DateTime.Parse(stringValue, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
+        }
+
+        /// <summary>
+        /// Convert a seconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        /// <param name="seconds"></param>
+        /// <returns></returns>
+        public static DateTime ConvertFromSeconds(double seconds) => _epoch.AddTicks((long)Math.Round(seconds * _ticksPerSecond));
+        /// <summary>
+        /// Convert a milliseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        /// <param name="milliseconds"></param>
+        /// <returns></returns>
+        public static DateTime ConvertFromMilliseconds(double milliseconds) => _epoch.AddTicks((long)Math.Round(milliseconds * TimeSpan.TicksPerMillisecond));
+        /// <summary>
+        /// Convert a microseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        /// <param name="microseconds"></param>
+        /// <returns></returns>
+        public static DateTime ConvertFromMicroseconds(long 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>
+        /// <returns></returns>
+        public static DateTime ConvertFromNanoseconds(long nanoseconds) => _epoch.AddTicks((long)Math.Round(nanoseconds * _ticksPerNanosecond));
+        /// <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);
+
+
+        /// <inheritdoc />
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            var datetimeValue = (DateTime?)value;
+            if (datetimeValue == null)
+                writer.WriteValue((DateTime?)null);
+            if(datetimeValue == default(DateTime))
+                writer.WriteValue((DateTime?)null);
+            else
+                writer.WriteValue((long)Math.Round(((DateTime)value! - new DateTime(1970, 1, 1)).TotalMilliseconds));
+        }
+    }
+}

CryptoExchange.Net/Converters/JsonNet/DecimalStringWriterConverter.cs

@@ -0,0 +1,27 @@
+using Newtonsoft.Json;
+using System;
+using System.Globalization;
+
+namespace CryptoExchange.Net.Converters.JsonNet
+{
+    /// <summary>
+    /// Converter for serializing decimal values as string
+    /// </summary>
+    public class DecimalStringWriterConverter : JsonConverter
+    {
+        /// <inheritdoc />
+        public override bool CanRead => false;
+
+        /// <inheritdoc />
+        public override bool CanConvert(Type objectType) => objectType == typeof(decimal) || objectType == typeof(decimal?);
+
+        /// <inheritdoc />
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc />
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer) => writer.WriteValue(((decimal?)value)?.ToString(CultureInfo.InvariantCulture) ?? null);
+    }
+}

CryptoExchange.Net/Converters/JsonNet/EnumConverter.cs

@@ -0,0 +1,176 @@
+using CryptoExchange.Net.Attributes;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+namespace CryptoExchange.Net.Converters.JsonNet
+{
+    /// <summary>
+    /// Converter for enum values. Enums entries should be noted with a MapAttribute to map the enum value to a string value
+    /// </summary>
+    public class EnumConverter : JsonConverter
+    {
+        private bool _warnOnMissingEntry = true;
+        private bool _writeAsInt;
+
+        /// <summary>
+        /// </summary>
+        public EnumConverter() { }
+
+        /// <summary>
+        /// </summary>
+        /// <param name="writeAsInt"></param>
+        /// <param name="warnOnMissingEntry"></param>
+        public EnumConverter(bool writeAsInt, bool warnOnMissingEntry)
+        {
+            _writeAsInt = writeAsInt;
+            _warnOnMissingEntry = warnOnMissingEntry;
+        }   
+
+        private static readonly ConcurrentDictionary<Type, List<KeyValuePair<object, string>>> _mapping = new();
+
+        /// <inheritdoc />
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType.IsEnum || Nullable.GetUnderlyingType(objectType)?.IsEnum == true;
+        }
+
+        /// <inheritdoc />
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            var enumType = Nullable.GetUnderlyingType(objectType) ?? objectType;
+            if (!_mapping.TryGetValue(enumType, out var mapping))
+                mapping = AddMapping(enumType);
+
+            var stringValue = reader.Value?.ToString();
+            if (stringValue == null || stringValue == "")
+            {
+                // Received null value
+                var emptyResult = GetDefaultValue(objectType, enumType);
+                if(emptyResult != null)
+                    // If the property we're parsing to isn't nullable there isn't a correct way to return this as null will either throw an exception (.net framework) or the default enum value (dotnet core).
+                    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: {enumType.Name}. If you think {enumType.Name} should be nullable please open an issue on the Github repo");
+
+                return emptyResult;
+            }
+
+            if (!GetValue(enumType, mapping, stringValue!, out var result))
+            {
+                var defaultValue = GetDefaultValue(objectType, enumType);
+                if (string.IsNullOrWhiteSpace(stringValue))
+                {
+                    if (defaultValue != null)
+                        // We received an empty string and have no mapping for it, and the property isn't nullable
+                        Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Received empty string as enum value, but property type is not a nullable enum. EnumType: {enumType.Name}. If you think {enumType.Name} should be nullable please open an issue on the Github repo");
+                }
+                else
+                {
+                    // We received an enum value but weren't able to parse it.
+                    if (_warnOnMissingEntry)
+                        Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Cannot map enum value. EnumType: {enumType.Name}, Value: {reader.Value}, Known values: {string.Join(", ", mapping.Select(m => m.Value))}. If you think {reader.Value} should added please open an issue on the Github repo");
+                }
+            
+                return defaultValue;
+            }
+
+            return result;
+        }
+
+        private static object? GetDefaultValue(Type objectType, Type enumType)
+        {
+            if (Nullable.GetUnderlyingType(objectType) != null)
+                return null;
+
+            return Activator.CreateInstance(enumType); // return default value
+        }
+
+        private static List<KeyValuePair<object, string>> AddMapping(Type objectType) 
+        {
+            var mapping = new List<KeyValuePair<object, string>>();
+            var enumMembers = objectType.GetMembers();
+            foreach (var member in enumMembers)
+            {
+                var maps = member.GetCustomAttributes(typeof(MapAttribute), false);
+                foreach (MapAttribute attribute in maps)
+                {
+                    foreach (var value in attribute.Values)
+                        mapping.Add(new KeyValuePair<object, string>(Enum.Parse(objectType, member.Name), value));
+                }
+            }
+            _mapping.TryAdd(objectType, mapping);
+            return mapping;
+        }
+
+        private static bool GetValue(Type objectType, List<KeyValuePair<object, string>> enumMapping, string value, out object? result)
+        {
+            // Check for exact match first, then if not found fallback to a case insensitive match 
+            var mapping = enumMapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCulture));
+            if (mapping.Equals(default(KeyValuePair<object, string>)))
+                mapping = enumMapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCultureIgnoreCase));
+
+            if (!mapping.Equals(default(KeyValuePair<object, string>)))
+            {
+                result = mapping.Key;
+                return true;
+            }
+
+            try
+            {
+                // If no explicit mapping is found try to parse string
+                result = Enum.Parse(objectType, value, true);
+                return true;
+            }
+            catch (Exception)
+            {
+                result = default;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Get the string value for an enum value using the MapAttribute mapping. When multiple values are mapped for a enum entry the first value will be returned
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="enumValue"></param>
+        /// <returns></returns>
+        [return: NotNullIfNotNull("enumValue")]
+        public static string? GetString<T>(T enumValue) => GetString(typeof(T), enumValue);     
+        
+
+        [return: NotNullIfNotNull("enumValue")]
+        private static string? GetString(Type objectType, object? enumValue)
+        {
+            objectType = Nullable.GetUnderlyingType(objectType) ?? objectType;
+
+            if (!_mapping.TryGetValue(objectType, out var mapping))
+                mapping = AddMapping(objectType);
+
+            return enumValue == null ? null : (mapping.FirstOrDefault(v => v.Key.Equals(enumValue)).Value ?? enumValue.ToString());
+        }
+
+        /// <inheritdoc />
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+            }
+            else
+            {
+                if (!_writeAsInt)
+                {
+                    var stringValue = GetString(value.GetType(), value);
+                    writer.WriteValue(stringValue);
+                }
+                else
+                {
+                    writer.WriteValue((int)value);
+                }
+            }
+        }
+    }
+}

CryptoExchange.Net/Converters/JsonNet/JsonNetMessageAccessor.cs

@@ -0,0 +1,338 @@
+using CryptoExchange.Net.Converters.MessageParsing;
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Converters.JsonNet
+{
+    /// <summary>
+    /// Json.Net message accessor
+    /// </summary>
+    public abstract class JsonNetMessageAccessor : IMessageAccessor
+    {
+        /// <summary>
+        /// The json token loaded
+        /// </summary>
+        protected JToken? _token;
+        private static readonly JsonSerializer _serializer = JsonSerializer.Create(SerializerOptions.WithConverters);
+
+        /// <inheritdoc />
+        public bool IsJson { get; protected set; }
+
+        /// <inheritdoc />
+        public abstract bool OriginalDataAvailable { get; }
+
+        /// <inheritdoc />
+        public object? Underlying => _token;
+
+        /// <inheritdoc />
+        public CallResult<object> Deserialize(Type type, MessagePath? path = null)
+        {
+            if (!IsJson)
+                return new CallResult<object>(GetOriginalString());
+
+            var source = _token;
+            if (path != null)
+                source = GetPathNode(path.Value);
+
+            try
+            {
+                var result = source!.ToObject(type, _serializer)!;
+                return new CallResult<object>(result);
+            }
+            catch (JsonReaderException jre)
+            {
+                var info = $"Deserialize JsonReaderException: {jre.Message}, Path: {jre.Path}, LineNumber: {jre.LineNumber}, LinePosition: {jre.LinePosition}";
+                return new CallResult<object>(new DeserializeError(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+            }
+            catch (JsonSerializationException jse)
+            {
+                var info = $"Deserialize JsonSerializationException: {jse.Message}";
+                return new CallResult<object>(new DeserializeError(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+            }
+            catch (Exception ex)
+            {
+                var exceptionInfo = ex.ToLogString();
+                var info = $"Deserialize Unknown Exception: {exceptionInfo}";
+                return new CallResult<object>(new DeserializeError(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+            }
+        }
+
+        /// <inheritdoc />
+        public CallResult<T> Deserialize<T>(MessagePath? path = null)
+        {
+            var source = _token;
+            if (path != null)
+                source = GetPathNode(path.Value);
+
+            try
+            {
+                var result = source!.ToObject<T>(_serializer)!;
+                return new CallResult<T>(result);
+            }
+            catch (JsonReaderException jre)
+            {
+                var info = $"Deserialize JsonReaderException: {jre.Message}, Path: {jre.Path}, LineNumber: {jre.LineNumber}, LinePosition: {jre.LinePosition}";
+                return new CallResult<T>(new DeserializeError(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+            }
+            catch (JsonSerializationException jse)
+            {
+                var info = $"Deserialize JsonSerializationException: {jse.Message}";
+                return new CallResult<T>(new DeserializeError(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+            }
+            catch (Exception ex)
+            {
+                var exceptionInfo = ex.ToLogString();
+                var info = $"Deserialize Unknown Exception: {exceptionInfo}";
+                return new CallResult<T>(new DeserializeError(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+            }
+        }
+
+        /// <inheritdoc />
+        public NodeType? GetNodeType()
+        {
+            if (!IsJson)
+                throw new InvalidOperationException("Can't access json data on non-json message");
+
+            if (_token == null)
+                return null;
+
+            if (_token.Type == JTokenType.Object)
+                return NodeType.Object;
+
+            if (_token.Type == JTokenType.Array)
+                return NodeType.Array;
+
+            return NodeType.Value;
+        }
+
+        /// <inheritdoc />
+        public NodeType? GetNodeType(MessagePath path)
+        {
+            if (!IsJson)
+                throw new InvalidOperationException("Can't access json data on non-json message");
+
+            var node = GetPathNode(path);
+            if (node == null)
+                return null;
+
+            if (node.Type == JTokenType.Object)
+                return NodeType.Object;
+
+            if (node.Type == JTokenType.Array)
+                return NodeType.Array;
+
+            return NodeType.Value;
+        }
+
+        /// <inheritdoc />
+        public T? GetValue<T>(MessagePath path)
+        {
+            if (!IsJson)
+                throw new InvalidOperationException("Can't access json data on non-json message");
+
+            var value = GetPathNode(path);
+            if (value == null)
+                return default;
+
+            if (value.Type == JTokenType.Object || value.Type == JTokenType.Array)
+                return default;
+
+            return value!.Value<T>();
+        }
+
+        /// <inheritdoc />
+        public List<T?>? GetValues<T>(MessagePath path)
+        {
+            if (!IsJson)
+                throw new InvalidOperationException("Can't access json data on non-json message");
+
+            var value = GetPathNode(path);
+            if (value == null)
+                return default;
+
+            if (value.Type == JTokenType.Object)
+                return default;
+
+            return value!.Values<T>().ToList();
+        }
+
+        private JToken? GetPathNode(MessagePath path)
+        {
+            if (!IsJson)
+                throw new InvalidOperationException("Can't access json data on non-json message");
+
+            var currentToken = _token;
+            foreach (var node in path)
+            {
+                if (node.Type == 0)
+                {
+                    // Int value
+                    var val = node.Index!.Value;
+                    if (currentToken!.Type != JTokenType.Array || ((JArray)currentToken).Count <= val)
+                        return null;
+
+                    currentToken = currentToken[val];
+                }
+                else if (node.Type == 1)
+                {
+                    // String value
+                    if (currentToken!.Type != JTokenType.Object)
+                        return null;
+
+                    currentToken = currentToken[node.Property!];
+                }
+                else
+                {
+                    // Property name
+                    if (currentToken!.Type != JTokenType.Object)
+                        return null;
+
+                    currentToken = (currentToken.First as JProperty)?.Name;
+                }
+
+                if (currentToken == null)
+                    return null;
+            }
+
+            return currentToken;
+        }
+
+        /// <inheritdoc />
+        public abstract string GetOriginalString();
+
+        /// <inheritdoc />
+        public abstract void Clear();
+    }
+
+    /// <summary>
+    /// Json.Net stream message accessor
+    /// </summary>
+    public class JsonNetStreamMessageAccessor : JsonNetMessageAccessor, IStreamMessageAccessor
+    {
+        private Stream? _stream;
+
+        /// <inheritdoc />
+        public override bool OriginalDataAvailable => _stream?.CanSeek == true;
+
+        /// <inheritdoc />
+        public async Task<CallResult> Read(Stream stream, bool bufferStream)
+        {
+            if (bufferStream && stream is not MemoryStream)
+            {
+                // We need to be buffer the stream, and it's not currently a seekable stream, so copy it to a new memory stream
+                _stream = new MemoryStream();
+                stream.CopyTo(_stream);
+                _stream.Position = 0;
+            }
+            else if (bufferStream)
+            {
+                // We need to buffer the stream, and the current stream is seekable, store as is
+                _stream = stream;
+            }
+            else
+            {
+                // We don't need to buffer the stream, so don't bother keeping the reference
+            }
+
+            var readStream = _stream ?? stream;
+            var length = readStream.CanSeek ? readStream.Length : 4096;
+            using var reader = new StreamReader(readStream, Encoding.UTF8, false, (int)Math.Max(2, length), true);
+            using var jsonTextReader = new JsonTextReader(reader);
+
+            try
+            {
+                _token = await JToken.LoadAsync(jsonTextReader).ConfigureAwait(false);
+                IsJson = true;
+                return new CallResult(null);
+            }
+            catch (Exception ex)
+            {
+                // Not a json message
+                IsJson = false;
+                return new CallResult(new ServerError("JsonError: " + ex.Message));
+            }
+
+        }
+        /// <inheritdoc />
+        public override string GetOriginalString()
+        {
+            if (_stream is null)
+                throw new NullReferenceException("Stream not initialized");
+
+            _stream.Position = 0;
+            using var textReader = new StreamReader(_stream, Encoding.UTF8, false, 1024, true);
+            return textReader.ReadToEnd();
+        }
+
+        /// <inheritdoc />
+        public override void Clear()
+        {
+            _stream?.Dispose();
+            _stream = null;
+            _token = null;
+        }
+
+    }
+
+    /// <summary>
+    /// Json.Net byte message accessor
+    /// </summary>
+    public class JsonNetByteMessageAccessor : JsonNetMessageAccessor, IByteMessageAccessor
+    {
+        private ReadOnlyMemory<byte> _bytes;
+
+        /// <inheritdoc />
+        public CallResult Read(ReadOnlyMemory<byte> data)
+        {
+            _bytes = data;
+
+            // Try getting the underlying byte[] instead of the ToArray to prevent creating a copy
+            using var stream = MemoryMarshal.TryGetArray(data, out var arraySegment)
+                ? new MemoryStream(arraySegment.Array, arraySegment.Offset, arraySegment.Count)
+                : new MemoryStream(data.ToArray());
+            using var reader = new StreamReader(stream, Encoding.UTF8, false, Math.Max(2, data.Length), true);
+            using var jsonTextReader = new JsonTextReader(reader);
+
+            try
+            {
+                _token = JToken.Load(jsonTextReader);
+                IsJson = true;
+                return new CallResult(null);
+            }
+            catch (Exception ex)
+            {
+                // Not a json message
+                IsJson = false;
+                return new CallResult(new ServerError("JsonError: " + ex.Message));
+            }
+        }
+
+        /// <inheritdoc />
+        public override string GetOriginalString() =>
+            // Netstandard 2.0 doesn't support GetString from a ReadonlySpan<byte>, so use ToArray there instead
+#if NETSTANDARD2_0
+            Encoding.UTF8.GetString(_bytes.ToArray());
+#else
+            Encoding.UTF8.GetString(_bytes.Span);
+#endif
+
+        /// <inheritdoc />
+        public override bool OriginalDataAvailable => true;
+
+        /// <inheritdoc />
+        public override void Clear()
+        {
+            _bytes = null;
+            _token = null;
+        }
+    }
+}

CryptoExchange.Net/Converters/JsonNet/JsonNetMessageSerializer.cs

@@ -0,0 +1,12 @@
+using CryptoExchange.Net.Interfaces;
+using Newtonsoft.Json;
+
+namespace CryptoExchange.Net.Converters.JsonNet
+{
+    /// <inheritdoc />
+    public class JsonNetMessageSerializer : IMessageSerializer
+    {
+        /// <inheritdoc />
+        public string Serialize(object message) => JsonConvert.SerializeObject(message, Formatting.None);
+    }
+}

CryptoExchange.Net/Converters/JsonNet/SerializerOptions.cs

@@ -0,0 +1,35 @@
+using Newtonsoft.Json;
+using System.Globalization;
+
+namespace CryptoExchange.Net.Converters.JsonNet
+{
+    /// <summary>
+    /// Serializer options
+    /// </summary>
+    public static class SerializerOptions
+    {
+        /// <summary>
+        /// Json serializer settings which includes the EnumConverter, DateTimeConverter and BoolConverter
+        /// </summary>
+        public static JsonSerializerSettings WithConverters => new JsonSerializerSettings
+        {
+            DateTimeZoneHandling = DateTimeZoneHandling.Utc,
+            Culture = CultureInfo.InvariantCulture,
+            Converters =
+            {
+                new EnumConverter(),
+                new DateTimeConverter(),
+                new BoolConverter()
+            }
+        };
+
+        /// <summary>
+        /// Default json serializer settings
+        /// </summary>
+        public static JsonSerializerSettings Default => new JsonSerializerSettings
+        {
+            DateTimeZoneHandling = DateTimeZoneHandling.Utc,
+            Culture = CultureInfo.InvariantCulture
+        };
+    }
+}

CryptoExchange.Net/Converters/MessageParsing/MessageNode.cs

@@ -0,0 +1,49 @@
+namespace CryptoExchange.Net.Converters.MessageParsing
+{
+    /// <summary>
+    /// Node accessor
+    /// </summary>
+    public struct NodeAccessor
+    {
+        /// <summary>
+        /// Index
+        /// </summary>
+        public int? Index { get; }
+        /// <summary>
+        /// Property name
+        /// </summary>
+        public string? Property { get; }
+
+        /// <summary>
+        /// Type (0 = int, 1 = string, 2 = prop name)
+        /// </summary>
+        public int Type { get; }
+
+        private NodeAccessor(int? index, string? property, int type)
+        {
+            Index = index;
+            Property = property;
+            Type = type;
+        }
+
+        /// <summary>
+        /// Create an int node accessor
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static NodeAccessor Int(int value) { return new NodeAccessor(value, null, 0); }
+
+        /// <summary>
+        /// Create a string node accessor
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static NodeAccessor String(string value) { return new NodeAccessor(null, value, 1); }
+
+        /// <summary>
+        /// Create a property name node accessor
+        /// </summary>
+        /// <returns></returns>
+        public static NodeAccessor PropertyName() { return new NodeAccessor(null, null, 2); }
+    }
+}

CryptoExchange.Net/Converters/MessageParsing/MessagePath.cs

@@ -0,0 +1,50 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.Converters.MessageParsing
+{
+    /// <summary>
+    /// Message access definition
+    /// </summary>
+    public struct MessagePath : IEnumerable<NodeAccessor>
+    {
+        private List<NodeAccessor> _path;
+
+        internal void Add(NodeAccessor node)
+        {
+            _path.Add(node);
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public MessagePath()
+        {
+            _path = new List<NodeAccessor>();
+        }
+
+        /// <summary>
+        /// Create a new message path
+        /// </summary>
+        /// <returns></returns>
+        public static MessagePath Get()
+        {
+            return new MessagePath();
+        }
+
+        /// <summary>
+        /// IEnumerable implementation
+        /// </summary>
+        /// <returns></returns>
+        public IEnumerator<NodeAccessor> GetEnumerator()
+        {
+            for (var i = 0; i < _path.Count; i++)
+                yield return _path[i];
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}

CryptoExchange.Net/Converters/MessageParsing/MessagePathExtension.cs

@@ -0,0 +1,43 @@
+namespace CryptoExchange.Net.Converters.MessageParsing
+{
+    /// <summary>
+    /// Message path extension methods
+    /// </summary>
+    public static class MessagePathExtension
+    {
+        /// <summary>
+        /// Add a string node accessor
+        /// </summary>
+        /// <param name="path"></param>
+        /// <param name="propName"></param>
+        /// <returns></returns>
+        public static MessagePath Property(this MessagePath path, string propName)
+        {
+            path.Add(NodeAccessor.String(propName));
+            return path;
+        }
+
+        /// <summary>
+        /// Add a property name node accessor
+        /// </summary>
+        /// <param name="path"></param>
+        /// <returns></returns>
+        public static MessagePath PropertyName(this MessagePath path)
+        {
+            path.Add(NodeAccessor.PropertyName());
+            return path;
+        }
+
+        /// <summary>
+        /// Add a int node accessor
+        /// </summary>
+        /// <param name="path"></param>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        public static MessagePath Index(this MessagePath path, int index)
+        {
+            path.Add(NodeAccessor.Int(index));
+            return path;
+        }
+    }
+}

CryptoExchange.Net/Converters/MessageParsing/NodeType.cs

@@ -0,0 +1,21 @@
+namespace CryptoExchange.Net.Converters.MessageParsing
+{
+    /// <summary>
+    /// Message node type
+    /// </summary>
+    public enum NodeType
+    {
+        /// <summary>
+        /// Array node
+        /// </summary>
+        Array,
+        /// <summary>
+        /// Object node
+        /// </summary>
+        Object,
+        /// <summary>
+        /// Value node
+        /// </summary>
+        Value
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/ArrayConverter.cs

@@ -0,0 +1,224 @@
+using System;
+using System.Collections.Concurrent;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using System.Text.Json.Serialization;
+using System.Text.Json;
+using CryptoExchange.Net.Attributes;
+using System.Collections.Generic;
+
+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
+    /// </summary>
+    public class ArrayConverter : JsonConverterFactory
+    {
+        /// <inheritdoc />
+        public override bool CanConvert(Type typeToConvert) => true;
+
+        /// <inheritdoc />
+        public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+        {
+            Type converterType = typeof(ArrayConverterInner<>).MakeGenericType(typeToConvert);
+            return (JsonConverter)Activator.CreateInstance(converterType);
+        }
+
+        private class ArrayPropertyInfo
+        {
+            public PropertyInfo PropertyInfo { get; set; } = null!;
+            public ArrayPropertyAttribute ArrayProperty { get; set; } = null!;
+            public Type? JsonConverterType { get; set; }
+            public bool DefaultDeserialization { get; set; }
+            public Type TargetType { get; set; } = null!;
+        }
+
+        private class ArrayConverterInner<T> : JsonConverter<T>
+        {
+            private static readonly ConcurrentDictionary<Type, List<ArrayPropertyInfo>> _typeAttributesCache = new ConcurrentDictionary<Type, List<ArrayPropertyInfo>>();
+            private static readonly ConcurrentDictionary<Type, JsonSerializerOptions> _converterOptionsCache = new ConcurrentDictionary<Type, JsonSerializerOptions>();
+
+            public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+            {
+                if (value == null)
+                {
+                    writer.WriteNullValue();
+                    return;
+                }
+
+                writer.WriteStartArray();
+
+                var valueType = value.GetType();
+                if (!_typeAttributesCache.TryGetValue(valueType, out var typeAttributes))
+                    typeAttributes = CacheTypeAttributes(valueType);
+
+                var ordered = typeAttributes.Where(x => x.ArrayProperty != null).OrderBy(p => p.ArrayProperty.Index);
+                var last = -1;
+                foreach (var prop in ordered)
+                {
+                    if (prop.ArrayProperty.Index == last)
+                        continue;
+
+                    while (prop.ArrayProperty.Index != last + 1)
+                    {
+                        writer.WriteNullValue();
+                        last += 1;
+                    }
+
+                    last = prop.ArrayProperty.Index;
+
+                    var objValue = prop.PropertyInfo.GetValue(value);
+                    if (objValue == null)
+                    {
+                        writer.WriteNullValue();
+                        continue;
+                    }
+
+                    JsonSerializerOptions? typeOptions = null;
+                    if (prop.JsonConverterType != null)
+                    {
+                        var converter = (JsonConverter)Activator.CreateInstance(prop.JsonConverterType);
+                        typeOptions = new JsonSerializerOptions();
+                        typeOptions.Converters.Clear();
+                        typeOptions.Converters.Add(converter);
+                    }
+
+                    if (prop.JsonConverterType == null && IsSimple(prop.PropertyInfo.PropertyType))
+                    {
+                        if (prop.PropertyInfo.PropertyType == typeof(string))
+                            writer.WriteStringValue(Convert.ToString(objValue, CultureInfo.InvariantCulture));
+                        else
+                            writer.WriteRawValue(Convert.ToString(objValue, CultureInfo.InvariantCulture));
+                    }
+                    else
+                    {
+                        JsonSerializer.Serialize(writer, objValue, typeOptions ?? options);
+                    }
+                }
+
+                writer.WriteEndArray();
+            }
+
+            /// <inheritdoc />
+            public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            {
+                if (reader.TokenType == JsonTokenType.Null)
+                    return default;
+
+                var result = Activator.CreateInstance(typeToConvert);
+                return (T)ParseObject(ref reader, result, typeToConvert, options);
+            }
+
+            private static bool IsSimple(Type type)
+            {
+                if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
+                {
+                    // nullable type, check if the nested type is simple.
+                    return IsSimple(type.GetGenericArguments()[0]);
+                }
+                return type.IsPrimitive
+                  || type.IsEnum
+                  || type == typeof(string)
+                  || type == typeof(decimal);
+            }
+
+            private static List<ArrayPropertyInfo> CacheTypeAttributes(Type type)
+            {
+                var attributes = new List<ArrayPropertyInfo>();
+                var properties = type.GetProperties();
+                foreach (var property in properties)
+                {
+                    var att = property.GetCustomAttribute<ArrayPropertyAttribute>();
+                    if (att == null)
+                        continue;
+
+                    attributes.Add(new ArrayPropertyInfo
+                    {
+                        ArrayProperty = att,
+                        PropertyInfo = property,
+                        DefaultDeserialization = property.GetCustomAttribute<JsonConversionAttribute>() != null,
+                        JsonConverterType = property.GetCustomAttribute<JsonConverterAttribute>()?.ConverterType ?? property.PropertyType.GetCustomAttribute<JsonConverterAttribute>()?.ConverterType,
+                        TargetType = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType
+                    });
+                }
+
+                _typeAttributesCache.TryAdd(type, attributes);
+                return attributes;
+            }
+
+            private static object ParseObject(ref Utf8JsonReader reader, object result, Type objectType, JsonSerializerOptions options)
+            {
+                if (reader.TokenType != JsonTokenType.StartArray)
+                    throw new Exception("Not an array");
+
+                if (!_typeAttributesCache.TryGetValue(objectType, out var attributes))
+                    attributes = CacheTypeAttributes(objectType);
+
+                int index = 0;
+                while (reader.Read())
+                {
+                    if (reader.TokenType == JsonTokenType.EndArray)
+                        break;
+
+                    var indexAttributes = attributes.Where(a => a.ArrayProperty.Index == index);
+                    if (!indexAttributes.Any())
+                    {
+                        index++;
+                        continue;
+                    }
+
+                    foreach (var attribute in indexAttributes)
+                    {
+                        var targetType = attribute.TargetType;
+                        object? value = null;
+                        if (attribute.JsonConverterType != null)
+                        {
+                            if (!_converterOptionsCache.TryGetValue(attribute.JsonConverterType, out var newOptions))
+                            {
+                                var converter = (JsonConverter)Activator.CreateInstance(attribute.JsonConverterType);
+                                newOptions = new JsonSerializerOptions
+                                {
+                                    NumberHandling = SerializerOptions.WithConverters.NumberHandling,
+                                    PropertyNameCaseInsensitive = SerializerOptions.WithConverters.PropertyNameCaseInsensitive,
+                                    Converters = { converter },
+                                };
+                                _converterOptionsCache.TryAdd(attribute.JsonConverterType, newOptions);
+                            }
+
+                            value = JsonDocument.ParseValue(ref reader).Deserialize(targetType, newOptions);
+                        }
+                        else if (attribute.DefaultDeserialization)
+                        {
+                            // Use default deserialization
+                            value = JsonDocument.ParseValue(ref reader).Deserialize(targetType, options);
+                        }
+                        else
+                        {
+                            value = reader.TokenType switch
+                            {
+                                JsonTokenType.Null => null,
+                                JsonTokenType.False => false,
+                                JsonTokenType.True => true,
+                                JsonTokenType.String => reader.GetString(),
+                                JsonTokenType.Number => reader.GetDecimal(),
+                                JsonTokenType.StartObject => JsonSerializer.Deserialize(ref reader, attribute.TargetType, options),
+                                _ => throw new NotImplementedException($"Array deserialization of type {reader.TokenType} not supported"),
+                            };
+                        }
+
+                        if (targetType.IsAssignableFrom(value?.GetType()))
+                            attribute.PropertyInfo.SetValue(result, value == null ? null : value);
+                        else
+                            attribute.PropertyInfo.SetValue(result, value == null ? null : Convert.ChangeType(value, targetType, CultureInfo.InvariantCulture));
+                    }
+
+                    index++;
+                }
+
+                return result;
+            }
+        }
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/BigDecimalConverter.cs

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

CryptoExchange.Net/Converters/SystemTextJson/BoolConverter.cs

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

CryptoExchange.Net/Converters/SystemTextJson/CommaSplitEnumConverter.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// Converter for comma seperated enum values
+    /// </summary>
+    public class CommaSplitEnumConverter<T> : JsonConverter<IEnumerable<T>> where T : Enum
+    {
+        /// <inheritdoc />
+        public override IEnumerable<T>? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            return (reader.GetString()?.Split(',').Select(x => EnumConverter.ParseString<T>(x)).ToArray() ?? new T[0])!;
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, IEnumerable<T> value, JsonSerializerOptions options)
+        {
+            writer.WriteStringValue(string.Join(",", value.Select(x => EnumConverter.GetString(x))));
+        }
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/DateTimeConverter.cs

@@ -0,0 +1,241 @@
+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
+{
+    /// <summary>
+    /// Date time converter
+    /// </summary>
+    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 double _ticksPerNanosecond = TimeSpan.TicksPerMillisecond / 1000d / 1000;
+
+        /// <inheritdoc />
+        public override bool CanConvert(Type typeToConvert)
+        {
+            return typeToConvert == typeof(DateTime) || typeToConvert == typeof(DateTime?);
+        }
+
+        /// <inheritdoc />
+        public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+        {
+            Type converterType = typeof(DateTimeConverterInner<>).MakeGenericType(typeToConvert);
+            return (JsonConverter)Activator.CreateInstance(converterType);
+        }
+
+        private class DateTimeConverterInner<T> : JsonConverter<T>
+        {
+            public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+                => (T)((object?)ReadDateTime(ref reader, typeToConvert, options) ?? default(T))!;
+
+            private DateTime? ReadDateTime(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            {
+                if (reader.TokenType == JsonTokenType.Null)
+                {
+                    if (typeToConvert == typeof(DateTime))
+                        Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | DateTime value of null, but property is not nullable");
+                    return default;
+                }
+
+                if (reader.TokenType is JsonTokenType.Number)
+                {
+                    var longValue = reader.GetDouble();
+                    if (longValue == 0 || longValue == -1)
+                        return default;
+
+                    return ParseFromDouble(longValue);
+                }
+                else if (reader.TokenType is JsonTokenType.String)
+                {
+                    var stringValue = reader.GetString();
+                    if (string.IsNullOrWhiteSpace(stringValue)
+                        || stringValue == "-1"
+                        || stringValue == "0001-01-01T00:00:00Z"
+                        || double.TryParse(stringValue, out var doubleVal) && doubleVal == 0)
+                    {
+                        return default;
+                    }
+
+                    return ParseFromString(stringValue!);
+                }
+                else
+                {
+                    return reader.GetDateTime();
+                }
+            }
+
+            public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+            {
+                if (value == null)
+                    writer.WriteNullValue();
+                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
+        /// </summary>
+        /// <param name="longValue"></param>
+        /// <returns></returns>
+        public static DateTime ParseFromDouble(double longValue)
+        {
+            if (longValue < 19999999999)
+                return ConvertFromSeconds(longValue);
+            if (longValue < 19999999999999)
+                return ConvertFromMilliseconds(longValue);
+            if (longValue < 19999999999999999)
+                return ConvertFromMicroseconds(longValue);
+
+            return ConvertFromNanoseconds(longValue);
+        }
+
+        /// <summary>
+        /// Parse a string value to datetime
+        /// </summary>
+        /// <param name="stringValue"></param>
+        /// <returns></returns>
+        public static DateTime ParseFromString(string stringValue)
+        {
+            if (stringValue!.Length == 12 && stringValue.StartsWith("202"))
+            {
+                // Parse 202303261200 format
+                if (!int.TryParse(stringValue.Substring(0, 4), out var year)
+                    || !int.TryParse(stringValue.Substring(4, 2), out var month)
+                    || !int.TryParse(stringValue.Substring(6, 2), out var day)
+                    || !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);
+                    return default;
+                }
+                return new DateTime(year, month, day, hour, minute, 0, DateTimeKind.Utc);
+            }
+
+            if (stringValue.Length == 8)
+            {
+                // Parse 20211103 format
+                if (!int.TryParse(stringValue.Substring(0, 4), out var year)
+                    || !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);
+                    return default;
+                }
+                return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
+            }
+
+            if (stringValue.Length == 6)
+            {
+                // Parse 211103 format
+                if (!int.TryParse(stringValue.Substring(0, 2), out var year)
+                    || !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);
+                    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))
+            {
+                // Parse 1637745563.000 format
+                if (doubleValue <= 0)
+                    return default;
+                if (doubleValue < 19999999999)
+                    return ConvertFromSeconds(doubleValue);
+                if (doubleValue < 19999999999999)
+                    return ConvertFromMilliseconds((long)doubleValue);
+                if (doubleValue < 19999999999999999)
+                    return ConvertFromMicroseconds((long)doubleValue);
+
+                return ConvertFromNanoseconds((long)doubleValue);
+            }
+
+            if (stringValue.Length == 10)
+            {
+                // Parse 2021-11-03 format
+                var values = stringValue.Split('-');
+                if (!int.TryParse(values[0], out var year)
+                    || !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);
+                    return default;
+                }
+
+                return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
+            }
+
+            return DateTime.Parse(stringValue, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
+        }
+
+        /// <summary>
+        /// Convert a seconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        /// <param name="seconds"></param>
+        /// <returns></returns>
+        public static DateTime ConvertFromSeconds(double seconds) => _epoch.AddTicks((long)Math.Round(seconds * _ticksPerSecond));
+        /// <summary>
+        /// Convert a milliseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        /// <param name="milliseconds"></param>
+        /// <returns></returns>
+        public static DateTime ConvertFromMilliseconds(double milliseconds) => _epoch.AddTicks((long)Math.Round(milliseconds * TimeSpan.TicksPerMillisecond));
+        /// <summary>
+        /// Convert a microseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        /// <param name="microseconds"></param>
+        /// <returns></returns>
+        public static DateTime ConvertFromMicroseconds(double microseconds) => _epoch.AddTicks((long)Math.Round(microseconds * _ticksPerMicrosecond));
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        /// <param name="nanoseconds"></param>
+        /// <returns></returns>
+        public static DateTime ConvertFromNanoseconds(double nanoseconds) => _epoch.AddTicks((long)Math.Round(nanoseconds * _ticksPerNanosecond));
+
+        /// <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

@@ -0,0 +1,60 @@
+using System;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// Decimal converter
+    /// </summary>
+    public class DecimalConverter : JsonConverter<decimal?>
+    {
+        /// <inheritdoc />
+        public override decimal? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType == JsonTokenType.Null)
+                return null;
+
+            if (reader.TokenType == JsonTokenType.String)
+            {
+                var value = reader.GetString();
+                if (string.IsNullOrEmpty(value) || string.Equals("null", value, StringComparison.OrdinalIgnoreCase))
+                    return null;
+
+                if (string.Equals("Infinity", value, StringComparison.Ordinal))
+                    // Infinity returned by the server, default to max value
+                    return decimal.MaxValue;
+
+                try
+                {
+                    return decimal.Parse(value, NumberStyles.Float, CultureInfo.InvariantCulture);
+                }
+                catch(OverflowException)
+                {
+                    // Value doesn't fit decimal, default to max value
+                    return decimal.MaxValue;
+                }
+            }
+
+            try
+            {
+                return reader.GetDecimal();
+            }
+            catch(FormatException)
+            {
+                // Format issue, assume value is too large
+                return decimal.MaxValue;
+            }
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, decimal? value, JsonSerializerOptions options)
+        {
+            if (value == null)
+                writer.WriteNullValue();
+            else
+                writer.WriteNumberValue(value.Value);
+        }
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/DecimalStringWriterConverter.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// Converter for serializing decimal values as string
+    /// </summary>
+    public class DecimalStringWriterConverter : JsonConverter<decimal>
+    {
+        /// <inheritdoc />
+        public override decimal Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, decimal value, JsonSerializerOptions options)
+            => writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture) ?? null);
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/EnumConverter.cs

@@ -0,0 +1,247 @@
+using CryptoExchange.Net.Attributes;
+using System;
+using System.Collections.Concurrent;
+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
+{
+    /// <summary>
+    /// Converter for enum values. Enums entries should be noted with a MapAttribute to map the enum value to a string value
+    /// </summary>
+    public class EnumConverter : JsonConverterFactory
+    {
+        private bool _warnOnMissingEntry = true;
+        private bool _writeAsInt;
+        private static readonly ConcurrentDictionary<Type, List<KeyValuePair<object, string>>> _mapping = new();
+
+        /// <summary>
+        /// </summary>
+        public EnumConverter() { }
+
+        /// <summary>
+        /// </summary>
+        /// <param name="writeAsInt"></param>
+        /// <param name="warnOnMissingEntry"></param>
+        public EnumConverter(bool writeAsInt, bool warnOnMissingEntry)
+        {
+            _writeAsInt = writeAsInt;
+            _warnOnMissingEntry = warnOnMissingEntry;
+        }
+
+        /// <inheritdoc />
+        public override bool CanConvert(Type typeToConvert)
+        {
+            return typeToConvert.IsEnum || Nullable.GetUnderlyingType(typeToConvert)?.IsEnum == true;
+        }
+
+        /// <inheritdoc />
+        public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+        {
+            JsonConverter converter = (JsonConverter)Activator.CreateInstance(
+                typeof(EnumConverterInner<>).MakeGenericType(
+                    new Type[] { typeToConvert }),
+                BindingFlags.Instance | BindingFlags.Public,
+                binder: null,
+                args: new object[] { _writeAsInt, _warnOnMissingEntry },
+                culture: null)!;
+
+            return converter;
+        }
+
+        private static List<KeyValuePair<object, string>> AddMapping(Type objectType)
+        {
+            var mapping = new List<KeyValuePair<object, string>>();
+            var enumMembers = objectType.GetMembers();
+            foreach (var member in enumMembers)
+            {
+                var maps = member.GetCustomAttributes(typeof(MapAttribute), false);
+                foreach (MapAttribute attribute in maps)
+                {
+                    foreach (var value in attribute.Values)
+                        mapping.Add(new KeyValuePair<object, string>(Enum.Parse(objectType, member.Name), value));
+                }
+            }
+            _mapping.TryAdd(objectType, mapping);
+            return mapping;
+        }
+
+        private class EnumConverterInner<T> : JsonConverter<T>
+        {
+            private bool _warnOnMissingEntry = true;
+            private bool _writeAsInt;
+
+            public EnumConverterInner(bool writeAsInt, bool warnOnMissingEntry)
+            {
+                _warnOnMissingEntry = warnOnMissingEntry;
+                _writeAsInt = writeAsInt;
+            }
+
+            public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            {
+                var enumType = Nullable.GetUnderlyingType(typeToConvert) ?? typeToConvert;
+                if (!_mapping.TryGetValue(enumType, out var mapping))
+                    mapping = AddMapping(enumType);
+
+                var stringValue = reader.TokenType switch
+                {
+                    JsonTokenType.String => reader.GetString(),
+                    JsonTokenType.Number => reader.GetInt16().ToString(),
+                    JsonTokenType.True => reader.GetBoolean().ToString(),
+                    JsonTokenType.False => reader.GetBoolean().ToString(),
+                    JsonTokenType.Null => null,
+                    _ => throw new Exception("Invalid token type for enum deserialization: " + reader.TokenType)
+                };
+
+                if (string.IsNullOrEmpty(stringValue))
+                {
+                    // Received null value
+                    var emptyResult = GetDefaultValue(typeToConvert, enumType);
+                    if (emptyResult != null)
+                        // If the property we're parsing to isn't nullable there isn't a correct way to return this as null will either throw an exception (.net framework) or the default enum value (dotnet core).
+                        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: {enumType.Name}. If you think {enumType.Name} should be nullable please open an issue on the Github repo");
+
+                    return (T?)emptyResult;
+                }
+
+                if (!GetValue(enumType, mapping, stringValue!, out var result))
+                {
+                    var defaultValue = GetDefaultValue(typeToConvert, enumType);
+                    if (string.IsNullOrWhiteSpace(stringValue))
+                    {
+                        if (defaultValue != null)
+                            // We received an empty string and have no mapping for it, and the property isn't nullable
+                            Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Received empty string as enum value, but property type is not a nullable enum. EnumType: {enumType.Name}. If you think {enumType.Name} should be nullable please open an issue on the Github repo");
+                    }
+                    else
+                    {
+                        // We received an enum value but weren't able to parse it.
+                        if (_warnOnMissingEntry)
+                            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");
+                    }
+
+                    return (T?)defaultValue;
+                }
+
+                return (T?)result;
+            }
+
+            public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+            {
+                if (value == null)
+                {
+                    writer.WriteNullValue();
+                }
+                else
+                {
+                    if (!_writeAsInt)
+                    {
+                        var stringValue = GetString(value.GetType(), value);
+                        writer.WriteStringValue(stringValue);
+                    }
+                    else
+                    {
+                        writer.WriteNumberValue((int)Convert.ChangeType(value, typeof(int)));
+                    }
+                }
+            }
+
+            private static object? GetDefaultValue(Type objectType, Type enumType)
+            {
+                if (Nullable.GetUnderlyingType(objectType) != null)
+                    return null;
+
+                return Activator.CreateInstance(enumType); // return default value
+            }
+
+            private static bool GetValue(Type objectType, List<KeyValuePair<object, string>> enumMapping, string value, out object? result)
+            {
+                // Check for exact match first, then if not found fallback to a case insensitive match 
+                var mapping = enumMapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCulture));
+                if (mapping.Equals(default(KeyValuePair<object, string>)))
+                    mapping = enumMapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCultureIgnoreCase));
+
+                if (!mapping.Equals(default(KeyValuePair<object, string>)))
+                {
+                    result = mapping.Key;
+                    return true;
+                }
+
+                try
+                {
+                    // If no explicit mapping is found try to parse string
+                    result = Enum.Parse(objectType, value, true);
+                    return true;
+                }
+                catch (Exception)
+                {
+                    result = default;
+                    return false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get the string value for an enum value using the MapAttribute mapping. When multiple values are mapped for a enum entry the first value will be returned
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="enumValue"></param>
+        /// <returns></returns>
+        [return: NotNullIfNotNull("enumValue")]
+        public static string? GetString<T>(T enumValue) => GetString(typeof(T), enumValue);
+
+        /// <summary>
+        /// Get the string value for an enum value using the MapAttribute mapping. When multiple values are mapped for a enum entry the first value will be returned
+        /// </summary>
+        /// <param name="objectType"></param>
+        /// <param name="enumValue"></param>
+        /// <returns></returns>
+        [return: NotNullIfNotNull("enumValue")]
+        public static string? GetString(Type objectType, object? enumValue)
+        {
+            objectType = Nullable.GetUnderlyingType(objectType) ?? objectType;
+
+            if (!_mapping.TryGetValue(objectType, out var mapping))
+                mapping = AddMapping(objectType);
+
+            return enumValue == null ? null : (mapping.FirstOrDefault(v => v.Key.Equals(enumValue)).Value ?? enumValue.ToString());
+        }
+
+        /// <summary>
+        /// Get the enum value from a string
+        /// </summary>
+        /// <typeparam name="T">Enum type</typeparam>
+        /// <param name="value">String value</param>
+        /// <returns></returns>
+        public static T? ParseString<T>(string value) where T : Enum
+        {
+            var type = typeof(T);
+            if (!_mapping.TryGetValue(type, out var enumMapping))
+                enumMapping = AddMapping(type);
+
+            var mapping = enumMapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCulture));
+            if (mapping.Equals(default(KeyValuePair<object, string>)))
+                mapping = enumMapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCultureIgnoreCase));
+
+            if (!mapping.Equals(default(KeyValuePair<object, string>)))
+            {
+                return (T)mapping.Key;
+            }
+
+            try
+            {
+                // If no explicit mapping is found try to parse string
+                return (T)Enum.Parse(type, value, true);
+            }
+            catch (Exception)
+            {
+                return default;
+            }
+        }
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/IntConverter.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// Int converter
+    /// </summary>
+    public class IntConverter : JsonConverter<int?>
+    {
+        /// <inheritdoc />
+        public override int? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType == JsonTokenType.Null)
+                return null;
+
+            if (reader.TokenType == JsonTokenType.String)
+            {
+                var value = reader.GetString();
+                if (string.IsNullOrEmpty(value))
+                    return null;
+
+                return int.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture);
+            }
+
+            return reader.GetInt32();
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, int? value, JsonSerializerOptions options)
+        {
+            if (value == null)
+                writer.WriteNullValue();
+            else
+                writer.WriteNumberValue(value.Value);
+        }
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/JsonConverterCtorAttribute.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// Attribute for allowing specifying a JsonConverter with constructor parameters
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    [AttributeUsage(AttributeTargets.Property)]
+    public class JsonConverterCtorAttribute<T> : JsonConverterAttribute where T : JsonConverter
+    {
+        private readonly object[] _parameters;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public JsonConverterCtorAttribute(params object[] parameters) => _parameters = parameters;
+
+        /// <inheritdoc />
+        public override JsonConverter CreateConverter(Type typeToConvert)
+        {
+            return (T)Activator.CreateInstance(typeof(T), _parameters);
+        }
+    }
+
+}

CryptoExchange.Net/Converters/SystemTextJson/LongConverter.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// Int converter
+    /// </summary>
+    public class LongConverter : JsonConverter<long?>
+    {
+        /// <inheritdoc />
+        public override long? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType == JsonTokenType.Null)
+                return null;
+
+            if (reader.TokenType == JsonTokenType.String)
+            {
+                var value = reader.GetString();
+                if (string.IsNullOrEmpty(value))
+                    return null;
+
+                return long.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture);
+            }
+
+            return reader.GetInt64();
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, long? value, JsonSerializerOptions options)
+        {
+            if (value == null)
+                writer.WriteNullValue();
+            else
+                writer.WriteNumberValue(value.Value);
+        }
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/NumberStringConverter.cs

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

CryptoExchange.Net/Converters/SystemTextJson/ObjectStringConverter.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Text.Json.Serialization;
+using System.Text.Json;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class ObjectStringConverter<T> : JsonConverter<T>
+    {
+        /// <inheritdoc />
+        public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType == JsonTokenType.Null)
+                return default;
+
+            var value = reader.GetString();
+            if (string.IsNullOrEmpty(value))
+                return default;
+
+            return (T?)JsonDocument.Parse(value!).Deserialize(typeof(T));
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, T? value, JsonSerializerOptions options)
+        {
+            if (value is null)
+                writer.WriteStringValue("");
+
+            writer.WriteStringValue(JsonSerializer.Serialize(value, options));
+        }
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/ReplaceConverter.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// Replace a value on a string property
+    /// </summary>
+    public class ReplaceConverter : JsonConverter<string>
+    {
+        private readonly (string ValueToReplace, string ValueToReplaceWith)[] _replacementSets;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ReplaceConverter(params string[] replaceSets)
+        {
+            _replacementSets = replaceSets.Select(x =>
+            {
+                var split = x.Split(new string[] { "->" }, StringSplitOptions.None);
+                if (split.Length != 2)
+                    throw new ArgumentException("Invalid replacement config");
+                return (split[0], split[1]);
+            }).ToArray();
+        }
+
+        /// <inheritdoc />
+        public override string? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            var value = reader.GetString();
+            foreach (var set in _replacementSets)
+                value = value?.Replace(set.ValueToReplace, set.ValueToReplaceWith);
+            return value;
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options) => writer.WriteStringValue(value);
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/SerializerOptions.cs

@@ -0,0 +1,29 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// Serializer options
+    /// </summary>
+    public static class SerializerOptions
+    {
+        /// <summary>
+        /// Json serializer settings which includes the EnumConverter, DateTimeConverter, BoolConverter and DecimalConverter
+        /// </summary>
+        public static JsonSerializerOptions WithConverters { get; } = new JsonSerializerOptions
+        {
+            NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.AllowNamedFloatingPointLiterals,
+            PropertyNameCaseInsensitive = false,
+            Converters =
+                    {
+                        new DateTimeConverter(),
+                        new EnumConverter(),
+                        new BoolConverter(),
+                        new DecimalConverter(),
+                        new IntConverter(),
+                        new LongConverter()
+                    }
+        };
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/SystemTextJsonMessageAccessor.cs

@@ -0,0 +1,336 @@
+using CryptoExchange.Net.Converters.MessageParsing;
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// System.Text.Json message accessor
+    /// </summary>
+    public abstract class SystemTextJsonMessageAccessor : IMessageAccessor
+    {
+        /// <summary>
+        /// The JsonDocument loaded
+        /// </summary>
+        protected JsonDocument? _document;
+
+        private static JsonSerializerOptions _serializerOptions = SerializerOptions.WithConverters;
+
+        /// <inheritdoc />
+        public bool IsJson { get; set; }
+
+        /// <inheritdoc />
+        public abstract bool OriginalDataAvailable { get; }
+
+        /// <inheritdoc />
+        public object? Underlying => throw new NotImplementedException();
+
+        /// <inheritdoc />
+        public CallResult<object> Deserialize(Type type, MessagePath? path = null)
+        {
+            if (!IsJson)
+                return new CallResult<object>(GetOriginalString());
+
+            if (_document == null)
+                throw new InvalidOperationException("No json document loaded");
+
+            try
+            {
+                var result = _document.Deserialize(type, _serializerOptions);
+                return new CallResult<object>(result!);
+            }
+            catch (JsonException ex)
+            {
+                var info = $"Deserialize JsonException: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
+                return new CallResult<object>(new DeserializeError(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+            }
+            catch (Exception ex)
+            {
+                var info = $"Deserialize unknown Exception: {ex.Message}";
+                return new CallResult<object>(new DeserializeError(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+            }
+        }
+
+        /// <inheritdoc />
+        public CallResult<T> Deserialize<T>(MessagePath? path = null)
+        {
+            if (_document == null)
+                throw new InvalidOperationException("No json document loaded");
+
+            try
+            {
+                var result = _document.Deserialize<T>(_serializerOptions);
+                return new CallResult<T>(result!);
+            }
+            catch (JsonException ex)
+            {
+                var info = $"Deserialize JsonException: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
+                return new CallResult<T>(new DeserializeError(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+            }
+            catch (Exception ex)
+            {
+                var info = $"Unknown exception: {ex.Message}";
+                return new CallResult<T>(new DeserializeError(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+            }
+        }
+
+        /// <inheritdoc />
+        public NodeType? GetNodeType()
+        {
+            if (!IsJson)
+                throw new InvalidOperationException("Can't access json data on non-json message");
+
+            if (_document == null)
+                throw new InvalidOperationException("No json document loaded");
+
+            return _document.RootElement.ValueKind switch
+            {
+                JsonValueKind.Object => NodeType.Object,
+                JsonValueKind.Array => NodeType.Array,
+                _ => NodeType.Value
+            };
+        }
+
+        /// <inheritdoc />
+        public NodeType? GetNodeType(MessagePath path)
+        {
+            if (!IsJson)
+                throw new InvalidOperationException("Can't access json data on non-json message");
+
+            var node = GetPathNode(path);
+            if (!node.HasValue)
+                return null;
+
+            return node.Value.ValueKind switch
+            {
+                JsonValueKind.Object => NodeType.Object,
+                JsonValueKind.Array => NodeType.Array,
+                _ => NodeType.Value
+            };
+        }
+
+        /// <inheritdoc />
+        public T? GetValue<T>(MessagePath path)
+        {
+            if (!IsJson)
+                throw new InvalidOperationException("Can't access json data on non-json message");
+
+            var value = GetPathNode(path);
+            if (value == null)
+                return default;
+
+            if (value.Value.ValueKind == JsonValueKind.Object || value.Value.ValueKind == JsonValueKind.Array)
+            {
+                try
+                {
+                    return value.Value.Deserialize<T>(_serializerOptions);
+                }
+                catch { }
+                return default;
+            }
+
+            if (typeof(T) == typeof(string))
+            {
+                if (value.Value.ValueKind == JsonValueKind.Number)
+                    return (T)(object)value.Value.GetInt64().ToString();
+            }
+
+            return value.Value.Deserialize<T>();
+        }
+
+        /// <inheritdoc />
+        public List<T?>? GetValues<T>(MessagePath path)
+        {
+            if (!IsJson)
+                throw new InvalidOperationException("Can't access json data on non-json message");
+
+            var value = GetPathNode(path);
+            if (value == null)
+                return default;
+
+            if (value.Value.ValueKind != JsonValueKind.Array)
+                return default;
+
+            return value.Value.Deserialize<List<T>>()!;
+        }
+
+        private JsonElement? GetPathNode(MessagePath path)
+        {
+            if (!IsJson)
+                throw new InvalidOperationException("Can't access json data on non-json message");
+
+            if (_document == null)
+                throw new InvalidOperationException("No json document loaded");
+
+            JsonElement? currentToken = _document.RootElement;
+            foreach (var node in path)
+            {
+                if (node.Type == 0)
+                {
+                    // Int value
+                    var val = node.Index!.Value;
+                    if (currentToken!.Value.ValueKind != JsonValueKind.Array || currentToken.Value.GetArrayLength() <= val)
+                        return null;
+
+                    currentToken = currentToken.Value[val];
+                }
+                else if (node.Type == 1)
+                {
+                    // String value
+                    if (currentToken!.Value.ValueKind != JsonValueKind.Object)
+                        return null;
+
+                    if (!currentToken.Value.TryGetProperty(node.Property!, out var token))
+                        return null;
+                    currentToken = token;
+                }
+                else
+                {
+                    // Property name
+                    if (currentToken!.Value.ValueKind != JsonValueKind.Object)
+                        return null;
+
+                    throw new NotImplementedException();
+                }
+
+                if (currentToken == null)
+                    return null;
+            }
+
+            return currentToken;
+        }
+
+        /// <inheritdoc />
+        public abstract string GetOriginalString();
+
+        /// <inheritdoc />
+        public abstract void Clear();
+    }
+
+    /// <summary>
+    /// System.Text.Json stream message accessor
+    /// </summary>
+    public class SystemTextJsonStreamMessageAccessor : SystemTextJsonMessageAccessor, IStreamMessageAccessor
+    {
+        private Stream? _stream;
+
+        /// <inheritdoc />
+        public override bool OriginalDataAvailable => _stream?.CanSeek == true;
+
+        /// <inheritdoc />
+        public async Task<CallResult> Read(Stream stream, bool bufferStream)
+        {
+            if (bufferStream && stream is not MemoryStream)
+            {
+                // We need to be buffer the stream, and it's not currently a seekable stream, so copy it to a new memory stream
+                _stream = new MemoryStream();
+                stream.CopyTo(_stream);
+                _stream.Position = 0;
+            }
+            else if (bufferStream)
+            {
+                // We need to buffer the stream, and the current stream is seekable, store as is
+                _stream = stream;
+            }
+            else
+            {
+                // We don't need to buffer the stream, so don't bother keeping the reference
+            }
+
+            try
+            {
+                _document = await JsonDocument.ParseAsync(_stream ?? stream).ConfigureAwait(false);
+                IsJson = true;
+                return new CallResult(null);
+            }
+            catch (Exception ex)
+            {
+                // Not a json message
+                IsJson = false;
+                return new CallResult(new ServerError("JsonError: " + ex.Message));
+            }
+        }
+
+        /// <inheritdoc />
+        public override string GetOriginalString()
+        {
+            if (_stream is null)
+                throw new NullReferenceException("Stream not initialized");
+
+            _stream.Position = 0;
+            using var textReader = new StreamReader(_stream, Encoding.UTF8, false, 1024, true);
+            return textReader.ReadToEnd();
+        }
+
+        /// <inheritdoc />
+        public override void Clear()
+        {
+            _stream?.Dispose();
+            _stream = null;
+            _document?.Dispose();
+            _document = null;
+        }
+
+    }
+
+    /// <summary>
+    /// System.Text.Json byte message accessor
+    /// </summary>
+    public class SystemTextJsonByteMessageAccessor : SystemTextJsonMessageAccessor, IByteMessageAccessor
+    {
+        private ReadOnlyMemory<byte> _bytes;
+
+        /// <inheritdoc />
+        public CallResult Read(ReadOnlyMemory<byte> data)
+        {
+            _bytes = data;
+
+            try
+            {
+                var firstByte = data.Span[0];
+                if (firstByte != 0x7b && firstByte != 0x5b)
+                {
+                    // Value doesn't start with `{` or `[`, prevent deserialization attempt as it's slow
+                    IsJson = false;
+                    return new CallResult(new ServerError("Not a json value"));
+                }
+
+                _document = JsonDocument.Parse(data);
+                IsJson = true;
+                return new CallResult(null);
+            }
+            catch (Exception ex)
+            {
+                // Not a json message
+                IsJson = false;
+                return new CallResult(new ServerError("JsonError: " + ex.Message));
+            }
+        }
+
+        /// <inheritdoc />
+        public override string GetOriginalString() =>
+            // Netstandard 2.0 doesn't support GetString from a ReadonlySpan<byte>, so use ToArray there instead
+#if NETSTANDARD2_0
+            Encoding.UTF8.GetString(_bytes.ToArray());
+#else
+            Encoding.UTF8.GetString(_bytes.Span);
+#endif
+
+        /// <inheritdoc />
+        public override bool OriginalDataAvailable => true;
+
+        /// <inheritdoc />
+        public override void Clear()
+        {
+            _bytes = null;
+            _document?.Dispose();
+            _document = null;
+        }
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/SystemTextJsonMessageSerializer.cs

@@ -0,0 +1,12 @@
+using CryptoExchange.Net.Interfaces;
+using System.Text.Json;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <inheritdoc />
+    public class SystemTextJsonMessageSerializer : IMessageSerializer
+    {
+        /// <inheritdoc />
+        public string Serialize(object message) => JsonSerializer.Serialize(message, SerializerOptions.WithConverters);
+    }
+}

CryptoExchange.Net/Converters/TimestampConverter.cs

@@ -1,36 +0,0 @@
-using System;
-using Newtonsoft.Json;
-
-namespace CryptoExchange.Net.Converters
-{
-    /// <summary>
-    /// converter for milliseconds to datetime
-    /// </summary>
-    public class TimestampConverter : JsonConverter
-    {
-        /// <inheritdoc />
-        public override bool CanConvert(Type objectType)
-        {
-            return objectType == typeof(DateTime);
-        }
-
-        /// <inheritdoc />
-        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
-        {
-            if (reader.Value == null)
-                return null;
-
-            var t = long.Parse(reader.Value.ToString());
-            return new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(t);
-        }
-
-        /// <inheritdoc />
-        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
-        {
-            if(value == null)
-                writer.WriteValue((DateTime?)null);
-            else
-                writer.WriteValue((long)Math.Round(((DateTime)value - new DateTime(1970, 1, 1)).TotalMilliseconds));
-        }
-    }
-}

CryptoExchange.Net/Converters/TimestampNanoSecondsConverter.cs

@@ -1,35 +0,0 @@
-using System;
-using Newtonsoft.Json;
-
-namespace CryptoExchange.Net.Converters
-{
-    /// <summary>
-    /// Converter for nanoseconds to datetime
-    /// </summary>
-    public class TimestampNanoSecondsConverter : JsonConverter
-    {
-        private const decimal ticksPerNanosecond = TimeSpan.TicksPerMillisecond / 1000m / 1000;
-
-        /// <inheritdoc />
-        public override bool CanConvert(Type objectType)
-        {
-            return objectType == typeof(DateTime);
-        }
-
-        /// <inheritdoc />
-        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
-        {
-            if (reader.Value == null)
-                return null;
-
-            var nanoSeconds = long.Parse(reader.Value.ToString());
-            return new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddTicks((long)Math.Round(nanoSeconds * ticksPerNanosecond));
-        }
-
-        /// <inheritdoc />
-        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
-        {
-            writer.WriteValue((long)Math.Round(((DateTime)value! - new DateTime(1970, 1, 1)).Ticks / ticksPerNanosecond));
-        }
-    }
-}

CryptoExchange.Net/Converters/TimestampSecondsConverter.cs

@@ -1,41 +0,0 @@
-using System;
-using System.Globalization;
-using Newtonsoft.Json;
-
-namespace CryptoExchange.Net.Converters
-{
-    /// <summary>
-    /// Converter for seconds to datetime
-    /// </summary>
-    public class TimestampSecondsConverter : JsonConverter
-    {
-        /// <inheritdoc />
-        public override bool CanConvert(Type objectType)
-        {
-            return objectType == typeof(DateTime);
-        }
-
-        /// <inheritdoc />
-        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
-        {
-            if (reader.Value == null)
-                return null;
-
-            if (reader.Value is double d)
-                return new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(d);
-
-            var t = double.Parse(reader.Value.ToString(), CultureInfo.InvariantCulture);
-            // Set ticks instead of seconds or milliseconds, because AddSeconds/AddMilliseconds rounds to nearest millisecond
-            return new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddTicks((long)(t * TimeSpan.TicksPerSecond)); 
-        }
-
-        /// <inheritdoc />
-        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
-        {
-            if (value == null)
-                writer.WriteValue((DateTime?)null);
-            else
-                writer.WriteValue((long)Math.Round(((DateTime)value! - new DateTime(1970, 1, 1)).TotalSeconds));
-        }
-    }
-}

CryptoExchange.Net/Converters/TimestampStringConverter.cs

@@ -1,44 +0,0 @@
-using System;
-using Newtonsoft.Json;
-
-namespace CryptoExchange.Net.Converters
-{
-    /// <summary>
-    /// converter for datetime string (yyyymmdd) to datetime
-    /// </summary>
-    public class TimestampStringConverter : JsonConverter
-    {
-        /// <inheritdoc />
-        public override bool CanConvert(Type objectType)
-        {
-            return objectType == typeof(DateTime);
-        }
-
-        /// <inheritdoc />
-        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
-        {
-            if (reader.Value == null)
-                return null;
-
-            var value = reader.Value.ToString();
-            if (value.Length == 8)
-                return new DateTime(int.Parse(value.Substring(0, 4)), int.Parse(value.Substring(4, 2)), int.Parse(value.Substring(6, 2)), 0, 0, 0, DateTimeKind.Utc);
-            else if(value.Length == 6)
-                return new DateTime(int.Parse(value.Substring(0, 2)), int.Parse(value.Substring(2, 2)), int.Parse(value.Substring(4, 2)), 0, 0, 0, DateTimeKind.Utc);
-
-            throw new Exception("Unknown datetime value: " + value);
-        }
-
-        /// <inheritdoc />
-        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
-        {
-            if (value == null)
-                writer.WriteValue((DateTime?)null);
-            else
-            {
-                var dateTimeValue = (DateTime)value;
-                writer.WriteValue(int.Parse($"{dateTimeValue.Year}{dateTimeValue.Month}{dateTimeValue.Day}"));
-            }
-        }
-    }
-}

CryptoExchange.Net/Converters/UTCDateTimeConverter.cs

@@ -1,38 +0,0 @@
-using System;
-using Newtonsoft.Json;
-
-namespace CryptoExchange.Net.Converters
-{
-    /// <summary>
-    /// Converter for utc datetime
-    /// </summary>
-    public class UTCDateTimeConverter: JsonConverter
-    {
-        /// <inheritdoc />
-        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
-        {
-            writer.WriteValue(JsonConvert.SerializeObject(value));
-        }
-
-        /// <inheritdoc />
-        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
-        {
-            if (reader.Value == null)
-                return null;
-
-            DateTime value;
-            if (reader.Value is string s)
-                value = (DateTime)JsonConvert.DeserializeObject(s)!;
-            else
-                value = (DateTime) reader.Value;
-
-            return DateTime.SpecifyKind(value, DateTimeKind.Utc);
-        }
-
-        /// <inheritdoc />
-        public override bool CanConvert(Type objectType)
-        {
-            return objectType == typeof(DateTime) || objectType == typeof(DateTime?);
-        }
-    }
-}

CryptoExchange.Net/CryptoExchange.Net.csproj

@@ -5,21 +5,28 @@
   <PropertyGroup>
     <PackageId>CryptoExchange.Net</PackageId>
     <Authors>JKorf</Authors>
-    <Description>A base package for implementing cryptocurrency exchange API's</Description>
+    <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>4.2.8</PackageVersion>
+    <PackageVersion>8.4.1</PackageVersion>
-    <AssemblyVersion>4.2.8</AssemblyVersion>
+    <AssemblyVersion>8.4.1</AssemblyVersion>
-    <FileVersion>4.2.8</FileVersion>
+    <FileVersion>8.4.1</FileVersion>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
+    <PackageTags>OKX;OKX.Net;Mexc;Mexc.Net;Kucoin;Kucoin.Net;Kraken;Kraken.Net;Huobi;Huobi.Net;CoinEx;CoinEx.Net;Bybit;Bybit.Net;Bitget;Bitget.Net;Bitfinex;Bitfinex.Net;Binance;Binance.Net;CryptoCurrency;CryptoCurrency Exchange</PackageTags>
     <RepositoryType>git</RepositoryType>
     <RepositoryUrl>https://github.com/JKorf/CryptoExchange.Net.git</RepositoryUrl>
     <PackageProjectUrl>https://github.com/JKorf/CryptoExchange.Net</PackageProjectUrl>
     <NeutralLanguage>en</NeutralLanguage>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <PackageIcon>icon.png</PackageIcon>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-    <PackageReleaseNotes>4.2.8 - Fixed deadlock in socket receive, Fixed issue in reconnection handling when the client is disconnected again during resubscribing, Added some additional checking of socket state to prevent sending/expecting data when socket is not connected</PackageReleaseNotes>
+    <PackageReleaseNotes>https://github.com/JKorf/CryptoExchange.Net?tab=readme-ov-file#release-notes</PackageReleaseNotes>
     <Nullable>enable</Nullable>
-    <LangVersion>8.0</LangVersion>
+    <LangVersion>12.0</LangVersion>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
   </PropertyGroup>
+  <ItemGroup>
+    <None Include="Icon\icon.png" Pack="true" PackagePath="\" />
+    <None Include="..\README.md" Pack="true" PackagePath="\" />
+  </ItemGroup>
   <PropertyGroup Label="Deterministic Build" Condition="'$(Configuration)' == 'Release'">
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
     <IncludeSymbols>true</IncludeSymbols>
@@ -28,7 +35,7 @@
     <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
   </PropertyGroup>
   <ItemGroup Label="Deterministic Build" Condition="'$(Configuration)' == 'Release'">
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0">
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
@@ -37,15 +44,21 @@
     <DocumentationFile>CryptoExchange.Net.xml</DocumentationFile>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ConfigureAwaitChecker.Analyzer" Version="5.0.0">
+    <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="5.0.3">
+    <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="9.0.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="9.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="3.1.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="9.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.0" />
+    <PackageReference Include="System.Text.Json" Version="9.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="9.0.0" />
   </ItemGroup>
 </Project>

CryptoExchange.Net/ExchangeHelpers.cs

@@ -1,5 +1,11 @@
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.SharedApis;
 using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace CryptoExchange.Net
 {
@@ -8,6 +14,29 @@ namespace CryptoExchange.Net
     /// </summary>
     public static class ExchangeHelpers
     {
+        private const string _allowedRandomChars = "ABCDEFGHIJKLMONOPQRSTUVWXYZabcdefghijklmonopqrstuvwxyz0123456789";
+
+        private static readonly Dictionary<int, string> _monthSymbols = new Dictionary<int, string>()
+        {
+            { 1, "F" },
+            { 2, "G" },
+            { 3, "H" },
+            { 4, "J" },
+            { 5, "K" },
+            { 6, "M" },
+            { 7, "N" },
+            { 8, "Q" },
+            { 9, "U" },
+            { 10, "V" },
+            { 11, "X" },
+            { 12, "Z" },
+        };
+
+        /// <summary>
+        /// The last used id, use NextId() to get the next id and up this
+        /// </summary>
+        private static int _lastId;
+
         /// <summary>
         /// Clamp a value between a min and max
         /// </summary>
@@ -43,7 +72,14 @@ namespace CryptoExchange.Net
 
             var offset = value % step.Value;
             if(roundingType == RoundingType.Down)
+            {
                 value -= offset;
+            }
+            else if(roundingType == RoundingType.Up)
+            {
+                if (offset != 0)
+                    value += (step.Value - offset);
+            }
             else
             {
                 if (offset < step / 2)
@@ -96,17 +132,23 @@ namespace CryptoExchange.Net
         }
 
         /// <summary>
-        /// Rounds a value down to 
+        /// Rounds a value down 
         /// </summary>
-        /// <param name="i"></param>
-        /// <param name="decimalPlaces"></param>
-        /// <returns></returns>
         public static decimal RoundDown(decimal i, double decimalPlaces)
         {
             var power = Convert.ToDecimal(Math.Pow(10, decimalPlaces));
             return Math.Floor(i * power) / power;
         }
 
+        /// <summary>
+        /// Rounds a value up
+        /// </summary>
+        public static decimal RoundUp(decimal i, double decimalPlaces)
+        {
+            var power = Convert.ToDecimal(Math.Pow(10, decimalPlaces));
+            return Math.Ceiling(i * power) / power;
+        }
+
         /// <summary>
         /// Strips any trailing zero's of a decimal value, useful when converting the value to string.
         /// </summary>
@@ -116,5 +158,120 @@ namespace CryptoExchange.Net
         {
             return value / 1.000000000000000000000000000000000m;
         }
+
+        /// <summary>
+        /// Generate a new unique id. The id is staticly stored so it is guarenteed to be unique
+        /// </summary>
+        /// <returns></returns>
+        public static int NextId() => Interlocked.Increment(ref _lastId);
+
+        /// <summary>
+        /// Return the last unique id that was generated
+        /// </summary>
+        /// <returns></returns>
+        public static int LastId() => _lastId;
+
+        /// <summary>
+        /// Generate a random string of specified length
+        /// </summary>
+        /// <param name="length">Length of the random string</param>
+        /// <returns></returns>
+        public static string RandomString(int length)
+        {
+            var randomChars = new char[length];
+
+#if NETSTANDARD2_1_OR_GREATER
+            for (int i = 0; i < length; i++)
+                randomChars[i] = _allowedRandomChars[RandomNumberGenerator.GetInt32(0, _allowedRandomChars.Length)];
+#else
+            var random = new Random();
+            for (int i = 0; i < length; i++)
+                randomChars[i] = _allowedRandomChars[random.Next(0, _allowedRandomChars.Length)];
+#endif
+
+            return new string(randomChars);
+        }
+
+        /// <summary>
+        /// Generate a random string of specified length
+        /// </summary>
+        /// <param name="source">The initial string</param>
+        /// <param name="totalLength">Total length of the resulting string</param>
+        /// <returns></returns>
+        public static string AppendRandomString(string source, int totalLength)
+        {
+            if (totalLength < source.Length)
+                throw new ArgumentException("Total length smaller than source string length", nameof(totalLength));
+
+            if (totalLength == source.Length)
+                return source;
+
+            return source + RandomString(totalLength - source.Length);
+        }
+
+        /// <summary>
+        /// Get the month representation for futures symbol based on the delivery month
+        /// </summary>
+        /// <param name="time">Delivery time</param>
+        /// <returns></returns>
+        public static string GetDeliveryMonthSymbol(DateTime time) => _monthSymbols[time.Month];
+
+        /// <summary>
+        /// Execute multiple requests to retrieve multiple pages of the result set
+        /// </summary>
+        /// <typeparam name="T">Type of the client</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<IEnumerable<T>>> ExecutePages<T, U>(Func<U, INextPageToken?, CancellationToken, Task<ExchangeWebResult<IEnumerable<T>>>> paginatedFunc, U request, [EnumeratorCancellation]CancellationToken ct = default)
+        {
+            var result = new List<T>();
+            ExchangeWebResult<IEnumerable<T>> batch;
+            INextPageToken? nextPageToken = null;
+            while (true)
+            {
+                batch = await paginatedFunc(request, nextPageToken, ct).ConfigureAwait(false);
+                yield return batch;
+                if (!batch || ct.IsCancellationRequested)
+                    break;
+
+                result.AddRange(batch.Data);
+                nextPageToken = batch.NextPageToken;
+                if (nextPageToken == null)
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Apply the rules (price and quantity step size and decimals precision, min/max quantity) from the symbol to the quantity and price
+        /// </summary>
+        /// <param name="symbol">The symbol as retrieved from the exchange</param>
+        /// <param name="quantity">Quantity to trade</param>
+        /// <param name="price">Price to trade at</param>
+        /// <param name="adjustedQuantity">Quantity adjusted to match all trading rules</param>
+        /// <param name="adjustedPrice">Price adjusted to match all trading rules</param>
+        public static void ApplySymbolRules(SharedSpotSymbol symbol, decimal quantity, decimal? price, out decimal adjustedQuantity, out decimal? adjustedPrice)
+        {
+            adjustedPrice = price;
+            adjustedQuantity = quantity;
+            var minNotionalAdjust = false;
+
+            if (price != null)
+            {
+                adjustedPrice = AdjustValueStep(0, decimal.MaxValue, symbol.PriceStep, RoundingType.Down, price.Value);
+                adjustedPrice = symbol.PriceDecimals.HasValue ? RoundDown(price.Value, symbol.PriceDecimals.Value) : adjustedPrice;
+                if (adjustedPrice != 0 && adjustedPrice * quantity < symbol.MinNotionalValue)
+                {
+                    adjustedQuantity = symbol.MinNotionalValue.Value / adjustedPrice.Value;
+                    minNotionalAdjust = true;
+                }
+            }
+
+            adjustedQuantity = AdjustValueStep(symbol.MinTradeQuantity ?? 0, symbol.MaxTradeQuantity ?? decimal.MaxValue, symbol.QuantityStep, minNotionalAdjust ? RoundingType.Up : RoundingType.Down, adjustedQuantity);
+            adjustedQuantity = symbol.QuantityDecimals.HasValue ? (minNotionalAdjust ? RoundUp(adjustedQuantity, symbol.QuantityDecimals.Value) : RoundDown(adjustedQuantity, symbol.QuantityDecimals.Value)) : adjustedQuantity;
+
+        }
     }
 }

CryptoExchange.Net/ExchangeInterfaces/ICommonBalance.cs

@@ -1,21 +0,0 @@
-namespace CryptoExchange.Net.ExchangeInterfaces
-{
-    /// <summary>
-    /// Common balance
-    /// </summary>
-    public interface ICommonBalance
-    {
-        /// <summary>
-        /// The asset name
-        /// </summary>
-        public string CommonAsset { get; }
-        /// <summary>
-        /// Amount available
-        /// </summary>
-        public decimal CommonAvailable { get; }
-        /// <summary>
-        /// Total amount
-        /// </summary>
-        public decimal CommonTotal { get; }
-    }
-}

CryptoExchange.Net/ExchangeInterfaces/ICommonTrade.cs

@@ -1,35 +0,0 @@
-using System;
-
-namespace CryptoExchange.Net.ExchangeInterfaces
-{
-    /// <summary>
-    /// Common trade
-    /// </summary>
-    public interface ICommonTrade
-    {
-        /// <summary>
-        /// Id of the trade
-        /// </summary>
-        public string CommonId { get; }
-        /// <summary>
-        /// Price of the trade
-        /// </summary>
-        public decimal CommonPrice { get; }
-        /// <summary>
-        /// Quantity of the trade
-        /// </summary>
-        public decimal CommonQuantity { get; }
-        /// <summary>
-        /// Fee paid for the trade
-        /// </summary>
-        public decimal CommonFee { get; }
-        /// <summary>
-        /// The asset fee was paid in
-        /// </summary>
-        public string? CommonFeeAsset { get; }
-        /// <summary>
-        /// Trade time
-        /// </summary>
-        DateTime CommonTradeTime { get; }
-    }
-}

CryptoExchange.Net/ExchangeInterfaces/IExchangeClient.cs

@@ -1,177 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using CryptoExchange.Net.Objects;
-
-namespace CryptoExchange.Net.ExchangeInterfaces
-{
-    /// <summary>
-    /// Shared interface for exchange wrappers based on the CryptoExchange.Net package
-    /// </summary>
-    public interface IExchangeClient
-    {
-        /// <summary>
-        /// Should be triggered on order placing
-        /// </summary>
-        event Action<ICommonOrderId> OnOrderPlaced;
-        /// <summary>
-        /// Should be triggered on order cancelling
-        /// </summary>
-        event Action<ICommonOrderId> OnOrderCanceled;
-
-        /// <summary>
-        /// Get the symbol name based on a base and quote asset
-        /// </summary>
-        /// <param name="baseAsset"></param>
-        /// <param name="quoteAsset"></param>
-        /// <returns></returns>
-        string GetSymbolName(string baseAsset, string quoteAsset);
-
-        /// <summary>
-        /// Get a list of symbols for the exchange
-        /// </summary>
-        /// <returns></returns>
-        Task<WebCallResult<IEnumerable<ICommonSymbol>>> GetSymbolsAsync();
-
-        /// <summary>
-        /// Get a list of tickers for the exchange
-        /// </summary>
-        /// <returns></returns>
-        Task<WebCallResult<IEnumerable<ICommonTicker>>> GetTickersAsync();
-
-        /// <summary>
-        /// Get a ticker for the exchange
-        /// </summary>
-        /// <param name="symbol">The symbol to get klines for</param>
-        /// <returns></returns>
-        Task<WebCallResult<ICommonTicker>> GetTickerAsync(string symbol);
-
-        /// <summary>
-        /// Get a list of candles for a given symbol on the exchange
-        /// </summary>
-        /// <param name="symbol">The symbol to retrieve the candles for</param>
-        /// <param name="timespan">The timespan to retrieve the candles for. The supported value are dependent on the exchange</param>
-        /// <param name="startTime">[Optional] Start time to retrieve klines for</param>
-        /// <param name="endTime">[Optional] End time to retrieve klines for</param>
-        /// <param name="limit">[Optional] Max number of results</param>
-        /// <returns></returns>
-        Task<WebCallResult<IEnumerable<ICommonKline>>> GetKlinesAsync(string symbol, TimeSpan timespan, DateTime? startTime = null, DateTime? endTime = null, int? limit = null);
-        /// <summary>
-        /// Get the order book for a symbol
-        /// </summary>
-        /// <param name="symbol">The symbol to get the book for</param>
-        /// <returns></returns>
-        Task<WebCallResult<ICommonOrderBook>> GetOrderBookAsync(string symbol);
-        /// <summary>
-        /// The recent trades for a symbol
-        /// </summary>
-        /// <param name="symbol">The symbol to get the trades for</param>
-        /// <returns></returns>
-        Task<WebCallResult<IEnumerable<ICommonRecentTrade>>> GetRecentTradesAsync(string symbol);
-
-        /// <summary>
-        /// Place an order
-        /// </summary>
-        /// <param name="symbol">The symbol the order is for</param>
-        /// <param name="side">The side of the order</param>
-        /// <param name="type">The type of the order</param>
-        /// <param name="quantity">The quantity of the order</param>
-        /// <param name="price">The price of the order, only for limit orders</param>
-        /// <param name="accountId">[Optional] The account id to place the order on, required for some exchanges, ignored otherwise</param>
-        /// <returns>The id of the resulting order</returns>
-        Task<WebCallResult<ICommonOrderId>> PlaceOrderAsync(string symbol, OrderSide side, OrderType type, decimal quantity, decimal? price = null, string? accountId = null);
-        /// <summary>
-        /// Get an order by id
-        /// </summary>
-        /// <param name="orderId">The id</param>
-        /// <param name="symbol">[Optional] The symbol the order is on, required for some exchanges, ignored otherwise</param>
-        /// <returns></returns>
-        Task<WebCallResult<ICommonOrder>> GetOrderAsync(string orderId, string? symbol = null);
-        /// <summary>
-        /// Get trades for an order by id
-        /// </summary>
-        /// <param name="orderId">The id</param>
-        /// <param name="symbol">[Optional] The symbol the order is on, required for some exchanges, ignored otherwise</param>
-        /// <returns></returns>
-        Task<WebCallResult<IEnumerable<ICommonTrade>>> GetTradesAsync(string orderId, string? symbol = null);
-        /// <summary>
-        /// Get a list of open orders
-        /// </summary>
-        /// <param name="symbol">[Optional] The symbol to get open orders for, required for some exchanges, ignored otherwise</param>
-        /// <returns></returns>
-        Task<WebCallResult<IEnumerable<ICommonOrder>>> GetOpenOrdersAsync(string? symbol = null);
-
-        /// <summary>
-        /// Get a list of closed orders
-        /// </summary>
-        /// <param name="symbol">[Optional] The symbol to get closed orders for, required for some exchanges, ignored otherwise</param>
-        /// <returns></returns>
-        Task<WebCallResult<IEnumerable<ICommonOrder>>> GetClosedOrdersAsync(string? symbol = null);
-        /// <summary>
-        /// Cancel an order by id
-        /// </summary>
-        /// <param name="orderId">The id</param>
-        /// <param name="symbol">[Optional] The symbol the order is on, required for some exchanges, ignored otherwise</param>
-        /// <returns></returns>
-        Task<WebCallResult<ICommonOrderId>> CancelOrderAsync(string orderId, string? symbol = null);
-
-        /// <summary>
-        /// Get balances
-        /// </summary>
-        /// <param name="accountId">[Optional] The account id to retrieve balances for, required for some exchanges, ignored otherwise</param>
-        /// <returns></returns>
-        Task<WebCallResult<IEnumerable<ICommonBalance>>> GetBalancesAsync(string? accountId = null);
-
-        /// <summary>
-        /// Common order id
-        /// </summary>
-        public enum OrderType
-        {
-            /// <summary>
-            /// Limit type
-            /// </summary>
-            Limit,
-            /// <summary>
-            /// Market type
-            /// </summary>
-            Market,
-            /// <summary>
-            /// Other order type
-            /// </summary>
-            Other
-        }
-
-        /// <summary>
-        /// Common order side
-        /// </summary>
-        public enum OrderSide
-        {
-            /// <summary>
-            /// Buy order
-            /// </summary>
-            Buy,
-            /// <summary>
-            /// Sell order
-            /// </summary>
-            Sell
-        }
-        /// <summary>
-        /// Common order status
-        /// </summary>
-        public enum OrderStatus
-        {
-            /// <summary>
-            /// placed and not fully filled order
-            /// </summary>
-            Active,
-            /// <summary>
-            /// cancelled order
-            /// </summary>
-            Canceled,
-            /// <summary>
-            /// filled order
-            /// </summary>
-            Filled
-        }
-    }
-}

CryptoExchange.Net/ExchangeInterfaces/IKline.cs

@@ -1,35 +0,0 @@
-using System;
-
-namespace CryptoExchange.Net.ExchangeInterfaces
-{
-    /// <summary>
-    /// Common kline
-    /// </summary>
-    public interface ICommonKline
-    {
-        /// <summary>
-        /// High price for this kline
-        /// </summary>
-        decimal CommonHigh { get; }
-        /// <summary>
-        /// Low price for this kline
-        /// </summary>
-        decimal CommonLow { get; }
-        /// <summary>
-        /// Open price for this kline
-        /// </summary>
-        decimal CommonOpen { get; }
-        /// <summary>
-        /// Close price for this kline
-        /// </summary>
-        decimal CommonClose { get; }
-        /// <summary>
-        /// Open time for this kline
-        /// </summary>
-        DateTime CommonOpenTime { get; }
-        /// <summary>
-        /// Volume of this kline
-        /// </summary>
-        decimal CommonVolume { get; }
-    }
-}