Updated version

CryptoExchange.Net.UnitTests/BaseClientTests.cs

@@ -11,6 +11,66 @@ namespace CryptoExchange.Net.UnitTests
     [TestFixture()]
     public class BaseClientTests
     {
+        [TestCase]
+        public void SettingLogOutput_Should_RedirectLogOutput()
+        {
+            // arrange
+            var logger = new TestStringLogger();
+            var client = new TestBaseClient(new BaseRestClientOptions()
+            {
+                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, false)]
+        public void SettingLogLevel_Should_RestrictLogging(LogLevel? verbosity, LogLevel testVerbosity, bool expected)
+        {
+            // arrange
+            var logger = new TestStringLogger();
+            var options = new BaseRestClientOptions()
+            {
+                LogWriters = new List<ILogger> { logger }
+            };
+            if (verbosity != null)
+                options.LogLevel = verbosity.Value;
+            var client = new TestBaseClient(options);
+
+            // act
+            client.Log(testVerbosity, "Test");
+
+            // assert
+            Assert.AreEqual(!string.IsNullOrEmpty(logger.GetLogs()), expected);
+        }
+
         [TestCase]
         public void DeserializingValidJson_Should_GiveSuccessfulResult()
         {
@@ -18,7 +78,7 @@ namespace CryptoExchange.Net.UnitTests
             var client = new TestBaseClient();
 
             // act
-            var result = client.SubClient.Deserialize<object>("{\"testProperty\": 123}");
+            var result = client.Deserialize<object>("{\"testProperty\": 123}");
 
             // assert
             Assert.IsTrue(result.Success);
@@ -31,7 +91,7 @@ namespace CryptoExchange.Net.UnitTests
             var client = new TestBaseClient();
 
             // act
-            var result = client.SubClient.Deserialize<object>("{\"testProperty\": 123");
+            var result = client.Deserialize<object>("{\"testProperty\": 123");
 
             // assert
             Assert.IsFalse(result.Success);

CryptoExchange.Net.UnitTests/CallResultTests.cs

@@ -113,7 +113,6 @@ namespace CryptoExchange.Net.UnitTests
                 System.Net.HttpStatusCode.OK,
                 new List<KeyValuePair<string, IEnumerable<string>>>(),
                 TimeSpan.FromSeconds(1),
-                null,
                 "{}",
                 "https://test.com/api",
                 null,
@@ -141,7 +140,6 @@ namespace CryptoExchange.Net.UnitTests
                 System.Net.HttpStatusCode.OK,
                 new List<KeyValuePair<string, IEnumerable<string>>>(),
                 TimeSpan.FromSeconds(1),
-                null,
                 "{}",
                 "https://test.com/api",
                 null,

CryptoExchange.Net.UnitTests/OptionsTests.cs

@@ -1,6 +1,5 @@
 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;
@@ -35,7 +34,7 @@ namespace CryptoExchange.Net.UnitTests
             // act
             // assert
             Assert.Throws(typeof(ArgumentException),
-                () => new RestExchangeOptions<TestEnvironment, ApiCredentials>() { ApiCredentials = new ApiCredentials(key, secret) });
+                () => new RestApiClientOptions() { ApiCredentials = new ApiCredentials(key, secret) });
         }
 
         [Test]
@@ -58,96 +57,239 @@ namespace CryptoExchange.Net.UnitTests
         public void TestApiOptionsAreSet()
         {
             // arrange, act
-            var options = new TestClientOptions();
-            options.Api1Options.ApiCredentials = new ApiCredentials("123", "456");
-            options.Api2Options.ApiCredentials = new ApiCredentials("789", "101");
+            var options = new TestClientOptions
+            {
+                Api1Options = new RestApiClientOptions
+                {
+                    ApiCredentials = new ApiCredentials("123", "456"),
+                    BaseAddress = "http://test1.com"
+                },
+                Api2Options = new RestApiClientOptions
+                {
+                    ApiCredentials = new ApiCredentials("789", "101"),
+                    BaseAddress = "http://test2.com"
+                }
+            };
 
             // assert
             Assert.AreEqual(options.Api1Options.ApiCredentials.Key.GetString(), "123");
             Assert.AreEqual(options.Api1Options.ApiCredentials.Secret.GetString(), "456");
+            Assert.AreEqual(options.Api1Options.BaseAddress, "http://test1.com");
             Assert.AreEqual(options.Api2Options.ApiCredentials.Key.GetString(), "789");
             Assert.AreEqual(options.Api2Options.ApiCredentials.Secret.GetString(), "101");
+            Assert.AreEqual(options.Api2Options.BaseAddress, "http://test2.com");
+        }
+
+        [Test]
+        public void TestNotOverridenApiOptionsAreStillDefault()
+        {
+            // arrange, act
+            var options = new TestClientOptions
+            {
+                Api1Options = new RestApiClientOptions
+                {
+                    ApiCredentials = new ApiCredentials("123", "456"),
+                }
+            };
+
+            // assert
+            Assert.AreEqual(options.Api1Options.RateLimitingBehaviour, RateLimitingBehaviour.Wait);
+            Assert.AreEqual(options.Api1Options.BaseAddress, "https://api1.test.com/");
+            Assert.AreEqual(options.Api2Options.BaseAddress, "https://api2.test.com/");
+        }
+
+        [Test]
+        public void TestSettingDefaultBaseOptionsAreRespected()
+        {
+            // arrange
+            TestClientOptions.Default = new TestClientOptions
+            {
+                ApiCredentials = new ApiCredentials("123", "456"),
+                LogLevel = LogLevel.Trace
+            };
+
+            // act
+            var options = new TestClientOptions();
+
+            // assert
+            Assert.AreEqual(options.LogLevel, LogLevel.Trace);
+            Assert.AreEqual(options.ApiCredentials.Key.GetString(), "123");
+            Assert.AreEqual(options.ApiCredentials.Secret.GetString(), "456");
+        }
+
+        [Test]
+        public void TestSettingDefaultApiOptionsAreRespected()
+        {
+            // arrange
+            TestClientOptions.Default = new TestClientOptions
+            {
+                ApiCredentials = new ApiCredentials("123", "456"),
+                LogLevel = LogLevel.Trace,
+                Api1Options = new RestApiClientOptions
+                {
+                    ApiCredentials = new ApiCredentials("456", "789")
+                }
+            };
+
+            // act
+            var options = new TestClientOptions();
+
+            // assert
+            Assert.AreEqual(options.ApiCredentials.Key.GetString(), "123");
+            Assert.AreEqual(options.ApiCredentials.Secret.GetString(), "456");
+            Assert.AreEqual(options.Api1Options.BaseAddress, "https://api1.test.com/");
+            Assert.AreEqual(options.Api1Options.ApiCredentials.Key.GetString(), "456");
+            Assert.AreEqual(options.Api1Options.ApiCredentials.Secret.GetString(), "789");
+        }
+
+        [Test]
+        public void TestSettingDefaultApiOptionsWithSomeOverriddenAreRespected()
+        {
+            // arrange
+            TestClientOptions.Default = new TestClientOptions
+            {
+                ApiCredentials = new ApiCredentials("123", "456"),
+                LogLevel = LogLevel.Trace,
+                Api1Options = new RestApiClientOptions
+                {
+                    ApiCredentials = new ApiCredentials("456", "789")
+                },
+                Api2Options = new RestApiClientOptions
+                {
+                    ApiCredentials = new ApiCredentials("111", "222")
+                }
+            };
+
+            // act
+            var options = new TestClientOptions
+            {
+                Api1Options = new RestApiClientOptions
+                {
+                    ApiCredentials = new ApiCredentials("333", "444")
+                }
+            };
+
+            // assert
+            Assert.AreEqual(options.ApiCredentials.Key.GetString(), "123");
+            Assert.AreEqual(options.ApiCredentials.Secret.GetString(), "456");
+            Assert.AreEqual(options.Api1Options.ApiCredentials.Key.GetString(), "333");
+            Assert.AreEqual(options.Api1Options.ApiCredentials.Secret.GetString(), "444");
+            Assert.AreEqual(options.Api2Options.ApiCredentials.Key.GetString(), "111");
+            Assert.AreEqual(options.Api2Options.ApiCredentials.Secret.GetString(), "222");
         }
 
         [Test]
         public void TestClientUsesCorrectOptions()
         {
-            var client = new TestRestClient(options => {
-                options.Api1Options.ApiCredentials = new ApiCredentials("111", "222");
-                options.ApiCredentials = new ApiCredentials("333", "444");
+            var client = new TestRestClient(new TestClientOptions()
+            {
+                ApiCredentials = new ApiCredentials("123", "456"),
+                Api1Options = new RestApiClientOptions
+                {
+                    ApiCredentials = new ApiCredentials("111", "222")
+                }
             });
 
-            var authProvider1 = (TestAuthProvider)client.Api1.AuthenticationProvider;
-            var authProvider2 = (TestAuthProvider)client.Api2.AuthenticationProvider;
-            Assert.AreEqual(authProvider1.GetKey(), "111");
-            Assert.AreEqual(authProvider1.GetSecret(), "222");
-            Assert.AreEqual(authProvider2.GetKey(), "333");
-            Assert.AreEqual(authProvider2.GetSecret(), "444");
+            Assert.AreEqual(client.Api1.AuthenticationProvider.Credentials.Key.GetString(), "111");
+            Assert.AreEqual(client.Api1.AuthenticationProvider.Credentials.Secret.GetString(), "222");
+            Assert.AreEqual(client.Api2.AuthenticationProvider.Credentials.Key.GetString(), "123");
+            Assert.AreEqual(client.Api2.AuthenticationProvider.Credentials.Secret.GetString(), "456");
         }
 
         [Test]
         public void TestClientUsesCorrectOptionsWithDefault()
         {
-            TestClientOptions.Default.ApiCredentials = new ApiCredentials("123", "456");
-            TestClientOptions.Default.Api1Options.ApiCredentials = new ApiCredentials("111", "222");
+            TestClientOptions.Default = new TestClientOptions()
+            {
+                ApiCredentials = new ApiCredentials("123", "456"),
+                Api1Options = new RestApiClientOptions
+                {
+                    ApiCredentials = new ApiCredentials("111", "222")
+                }
+            };
 
             var client = new TestRestClient();
 
-            var authProvider1 = (TestAuthProvider)client.Api1.AuthenticationProvider;
-            var authProvider2 = (TestAuthProvider)client.Api2.AuthenticationProvider;
-            Assert.AreEqual(authProvider1.GetKey(), "111");
-            Assert.AreEqual(authProvider1.GetSecret(), "222");
-            Assert.AreEqual(authProvider2.GetKey(), "123");
-            Assert.AreEqual(authProvider2.GetSecret(), "456");
+            Assert.AreEqual(client.Api1.AuthenticationProvider.Credentials.Key.GetString(), "111");
+            Assert.AreEqual(client.Api1.AuthenticationProvider.Credentials.Secret.GetString(), "222");
+            Assert.AreEqual(client.Api2.AuthenticationProvider.Credentials.Key.GetString(), "123");
+            Assert.AreEqual(client.Api2.AuthenticationProvider.Credentials.Secret.GetString(), "456");
         }
 
         [Test]
         public void TestClientUsesCorrectOptionsWithOverridingDefault()
         {
-            TestClientOptions.Default.ApiCredentials = new ApiCredentials("123", "456");
-            TestClientOptions.Default.Api1Options.ApiCredentials = new ApiCredentials("111", "222");
-
-            var client = new TestRestClient(options =>
+            TestClientOptions.Default = new TestClientOptions()
             {
-                options.Api1Options.ApiCredentials = new ApiCredentials("333", "444");
-                options.Environment = new TestEnvironment("Test", "https://test.test");
+                ApiCredentials = new ApiCredentials("123", "456"),
+                Api1Options = new RestApiClientOptions
+                {
+                    ApiCredentials = new ApiCredentials("111", "222")
+                }
+            };
+
+            var client = new TestRestClient(new TestClientOptions
+            {
+                Api1Options = new RestApiClientOptions
+                {
+                    ApiCredentials = new ApiCredentials("333", "444")
+                },
+                Api2Options = new RestApiClientOptions()
+                {
+                    BaseAddress = "http://test.com"
+                }
             });
 
-            var authProvider1 = (TestAuthProvider)client.Api1.AuthenticationProvider;
-            var authProvider2 = (TestAuthProvider)client.Api2.AuthenticationProvider;
-            Assert.AreEqual(authProvider1.GetKey(), "333");
-            Assert.AreEqual(authProvider1.GetSecret(), "444");
-            Assert.AreEqual(authProvider2.GetKey(), "123");
-            Assert.AreEqual(authProvider2.GetSecret(), "456");
-            Assert.AreEqual(client.Api2.BaseAddress, "https://localhost:123");
+            Assert.AreEqual(client.Api1.AuthenticationProvider.Credentials.Key.GetString(), "333");
+            Assert.AreEqual(client.Api1.AuthenticationProvider.Credentials.Secret.GetString(), "444");
+            Assert.AreEqual(client.Api2.AuthenticationProvider.Credentials.Key.GetString(), "123");
+            Assert.AreEqual(client.Api2.AuthenticationProvider.Credentials.Secret.GetString(), "456");
+            Assert.AreEqual(client.Api2.BaseAddress, "http://test.com");
         }
     }
 
-    public class TestClientOptions: RestExchangeOptions<TestEnvironment, ApiCredentials>
+    public class TestClientOptions: BaseRestClientOptions
     {
         /// <summary>
         /// Default options for the futures client
         /// </summary>
-        public static TestClientOptions Default { get; set; } = new TestClientOptions()
-        {
-            Environment = new TestEnvironment("test", "https://test.com")
-        };
+        public static TestClientOptions Default { get; set; } = new TestClientOptions();
 
         /// <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 Copy()
+        private RestApiClientOptions _api1Options = new RestApiClientOptions("https://api1.test.com/");
+        public RestApiClientOptions Api1Options
         {
-            var options = Copy<TestClientOptions>();
-            options.Api1Options = Api1Options.Copy<RestApiOptions>();
-            options.Api2Options = Api2Options.Copy<RestApiOptions>();
-            return options;
+            get => _api1Options;
+            set => _api1Options = new RestApiClientOptions(_api1Options, value);
+        }
+
+        private RestApiClientOptions _api2Options = new RestApiClientOptions("https://api2.test.com/");
+        public RestApiClientOptions Api2Options
+        {
+            get => _api2Options;
+            set => _api2Options = new RestApiClientOptions(_api2Options, value);
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public TestClientOptions(): this(Default)
+        {
+        }
+
+        public TestClientOptions(TestClientOptions baseOn): base(baseOn)
+        {
+            if (baseOn == null)
+                return;
+
+            ReceiveWindow = baseOn.ReceiveWindow;
+
+            Api1Options = new RestApiClientOptions(baseOn.Api1Options, null);
+            Api2Options = new RestApiClientOptions(baseOn.Api2Options, null);
         }
     }
 }

CryptoExchange.Net.UnitTests/RestClientTests.cs

@@ -11,6 +11,7 @@ using CryptoExchange.Net.Interfaces;
 using Microsoft.Extensions.Logging;
 using System.Net.Http;
 using System.Threading.Tasks;
+using CryptoExchange.Net.Logging;
 using System.Threading;
 
 namespace CryptoExchange.Net.UnitTests
@@ -27,7 +28,7 @@ namespace CryptoExchange.Net.UnitTests
             client.SetResponse(JsonConvert.SerializeObject(expected), out _);
 
             // act
-            var result = client.Api1.Request<TestObject>().Result;
+            var result = client.Request<TestObject>().Result;
 
             // assert
             Assert.IsTrue(result.Success);
@@ -42,7 +43,7 @@ namespace CryptoExchange.Net.UnitTests
             client.SetResponse("{\"property\": 123", out _);
 
             // act
-            var result = client.Api1.Request<TestObject>().Result;
+            var result = client.Request<TestObject>().Result;
 
             // assert
             Assert.IsFalse(result.Success);
@@ -57,7 +58,7 @@ namespace CryptoExchange.Net.UnitTests
             client.SetErrorWithoutResponse(System.Net.HttpStatusCode.BadRequest, "Invalid request");
 
             // act
-            var result = await client.Api1.Request<TestObject>();
+            var result = await client.Request<TestObject>();
 
             // assert
             Assert.IsFalse(result.Success);
@@ -72,7 +73,7 @@ namespace CryptoExchange.Net.UnitTests
             client.SetErrorWithResponse("{\"errorMessage\": \"Invalid request\", \"errorCode\": 123}", System.Net.HttpStatusCode.BadRequest);
 
             // act
-            var result = await client.Api1.Request<TestObject>();
+            var result = await client.Request<TestObject>();
 
             // assert
             Assert.IsFalse(result.Success);
@@ -90,7 +91,7 @@ namespace CryptoExchange.Net.UnitTests
             client.SetErrorWithResponse("{\"errorMessage\": \"Invalid request\", \"errorCode\": 123}", System.Net.HttpStatusCode.BadRequest);
 
             // act
-            var result = await client.Api2.Request<TestObject>();
+            var result = await client.Request<TestObject>();
 
             // assert
             Assert.IsFalse(result.Success);
@@ -105,16 +106,23 @@ namespace CryptoExchange.Net.UnitTests
         {
             // arrange
             // act
-            var options = new TestClientOptions();
-            options.Api1Options.RateLimiters = new List<IRateLimiter> { new RateLimiter() };
-            options.Api1Options.RateLimitingBehaviour = RateLimitingBehaviour.Fail;
-            options.RequestTimeout = TimeSpan.FromMinutes(1);
-            var client = new TestBaseClient(options);
+            var client = new TestRestClient(new TestClientOptions()
+            {
+                Api1Options = new RestApiClientOptions
+                {
+                    BaseAddress = "http://test.address.com",
+                    RateLimiters = new List<IRateLimiter> { new RateLimiter() },
+                    RateLimitingBehaviour = RateLimitingBehaviour.Fail
+                },
+                RequestTimeout = TimeSpan.FromMinutes(1)
+            });
+
 
             // assert
+            Assert.IsTrue(((TestClientOptions)client.ClientOptions).Api1Options.BaseAddress == "http://test.address.com");
             Assert.IsTrue(((TestClientOptions)client.ClientOptions).Api1Options.RateLimiters.Count == 1);
             Assert.IsTrue(((TestClientOptions)client.ClientOptions).Api1Options.RateLimitingBehaviour == RateLimitingBehaviour.Fail);
-            Assert.IsTrue(((TestClientOptions)client.ClientOptions).RequestTimeout == TimeSpan.FromMinutes(1));
+            Assert.IsTrue(client.ClientOptions.RequestTimeout == TimeSpan.FromMinutes(1));
         }
 
         [TestCase("GET", HttpMethodParameterPosition.InUri)] // No need to test InBody for GET since thats not valid
@@ -128,13 +136,19 @@ namespace CryptoExchange.Net.UnitTests
         {
             // arrange
             // act
-            var client = new TestRestClient();
+            var client = new TestRestClient(new TestClientOptions()
+            {
+                Api1Options = new RestApiClientOptions
+                {
+                    BaseAddress = "http://test.address.com"
+                }
+            });
 
             client.Api1.SetParameterPosition(new HttpMethod(method), pos);
 
             client.SetResponse("{}", out var request);
 
-            await client.Api1.RequestWithParams<TestObject>(new HttpMethod(method), new Dictionary<string, object>
+            await client.RequestWithParams<TestObject>(new HttpMethod(method), new Dictionary<string, object>
             {
                 { "TestParam1", "Value1" },
                 { "TestParam2", 2 },
@@ -161,17 +175,20 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase(1, 2)]
         public async Task PartialEndpointRateLimiterBasics(int requests, double perSeconds)
         {
+            var log = new Log("Test");
+            log.Level = LogLevel.Trace;
+
             var rateLimiter = new RateLimiter();
             rateLimiter.AddPartialEndpointLimit("/sapi/", requests, TimeSpan.FromSeconds(perSeconds));
 
             for (var i = 0; i < requests + 1; i++)
             {
-                var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), "/sapi/v1/system/status", HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);             
+                var result1 = await rateLimiter.LimitRequestAsync(log, "/sapi/v1/system/status", HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);             
                 Assert.IsTrue(i == requests? result1.Data > 1 : result1.Data == 0);
             }
 
             await Task.Delay((int)Math.Round(perSeconds * 1000) + 10);
-            var result2 = await rateLimiter.LimitRequestAsync(new TraceLogger(), "/sapi/v1/system/status", HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            var result2 = await rateLimiter.LimitRequestAsync(log, "/sapi/v1/system/status", HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
             Assert.IsTrue(result2.Data == 0);
         }
 
@@ -182,12 +199,15 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase("/sapi/", true)]
         public async Task PartialEndpointRateLimiterEndpoints(string endpoint, bool expectLimiting)
         {
+            var log = new Log("Test");
+            log.Level = LogLevel.Trace;
+
             var rateLimiter = new RateLimiter();
             rateLimiter.AddPartialEndpointLimit("/sapi/", 1, TimeSpan.FromSeconds(0.1));
 
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+                var result1 = await rateLimiter.LimitRequestAsync(log, endpoint, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
                 bool expected = i == 1 ? (expectLimiting ? result1.Data > 1 : result1.Data == 0) : result1.Data == 0; 
                 Assert.IsTrue(expected);
             }
@@ -198,11 +218,14 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase("/sapi/test", "/sapi/", false)]
         public async Task PartialEndpointRateLimiterEndpoints(string endpoint1, string endpoint2, bool expectLimiting)
         {
+            var log = new Log("Test");
+            log.Level = LogLevel.Trace;
+
             var rateLimiter = new RateLimiter();
             rateLimiter.AddPartialEndpointLimit("/sapi/", 1, TimeSpan.FromSeconds(0.1), countPerEndpoint: true);
 
-            var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint1, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
-            var result2 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint2, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            var result1 = await rateLimiter.LimitRequestAsync(log, endpoint1, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            var result2 = await rateLimiter.LimitRequestAsync(log, endpoint2, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
             Assert.IsTrue(result1.Data == 0);            
             Assert.IsTrue(expectLimiting ? result2.Data > 0 : result2.Data == 0);            
         }
@@ -213,17 +236,20 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase(1, 2)]
         public async Task EndpointRateLimiterBasics(int requests, double perSeconds)
         {
+            var log = new Log("Test");
+            log.Level = LogLevel.Trace;
+
             var rateLimiter = new RateLimiter();
             rateLimiter.AddEndpointLimit("/sapi/test", requests, TimeSpan.FromSeconds(perSeconds));
 
             for (var i = 0; i < requests + 1; i++)
             {
-                var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), "/sapi/test", HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+                var result1 = await rateLimiter.LimitRequestAsync(log, "/sapi/test", HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
                 Assert.IsTrue(i == requests ? result1.Data > 1 : result1.Data == 0);
             }
 
             await Task.Delay((int)Math.Round(perSeconds * 1000) + 10);
-            var result2 = await rateLimiter.LimitRequestAsync(new TraceLogger(), "/sapi/test", HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            var result2 = await rateLimiter.LimitRequestAsync(log, "/sapi/test", HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
             Assert.IsTrue(result2.Data == 0);
         }
 
@@ -232,12 +258,15 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase("/sapi/test/123", false)]
         public async Task EndpointRateLimiterEndpoints(string endpoint, bool expectLimited)
         {
+            var log = new Log("Test");
+            log.Level = LogLevel.Trace;
+
             var rateLimiter = new RateLimiter();
             rateLimiter.AddEndpointLimit("/sapi/test", 1, TimeSpan.FromSeconds(0.1));
 
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+                var result1 = await rateLimiter.LimitRequestAsync(log, endpoint, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
                 bool expected = i == 1 ? (expectLimited ? result1.Data > 1 : result1.Data == 0) : result1.Data == 0; 
                 Assert.IsTrue(expected);
             }
@@ -249,12 +278,15 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase("/sapi/test23", false)]
         public async Task EndpointRateLimiterMultipleEndpoints(string endpoint, bool expectLimited)
         {
+            var log = new Log("Test");
+            log.Level = LogLevel.Trace;
+
             var rateLimiter = new RateLimiter();
             rateLimiter.AddEndpointLimit(new[] { "/sapi/test", "/sapi/test2" }, 1, TimeSpan.FromSeconds(0.1));
 
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+                var result1 = await rateLimiter.LimitRequestAsync(log, endpoint, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
                 bool expected = i == 1 ? (expectLimited ? result1.Data > 1 : result1.Data == 0) : result1.Data == 0;
                 Assert.IsTrue(expected);
             }
@@ -283,11 +315,14 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase(null, null, "/sapi/test", "/sapi/test", false, false, false, true)]
         public async Task ApiKeyRateLimiterBasics(string key1, string key2, string endpoint1, string endpoint2, bool signed1, bool signed2, bool onlyForSignedRequests, bool expectLimited)
         {
+            var log = new Log("Test");
+            log.Level = LogLevel.Trace;
+
             var rateLimiter = new RateLimiter();
             rateLimiter.AddApiKeyLimit(1, TimeSpan.FromSeconds(0.1), onlyForSignedRequests, false);
 
-            var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint1, HttpMethod.Get, signed1, key1?.ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
-            var result2 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint2, HttpMethod.Get, signed2, key2?.ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            var result1 = await rateLimiter.LimitRequestAsync(log, endpoint1, HttpMethod.Get, signed1, key1?.ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            var result2 = await rateLimiter.LimitRequestAsync(log, endpoint2, HttpMethod.Get, signed2, key2?.ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
             Assert.IsTrue(result1.Data == 0);
             Assert.IsTrue(expectLimited ? result2.Data > 0 : result2.Data == 0);            
         }
@@ -297,11 +332,14 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase("/", "/sapi/test2", true)]
         public async Task TotalRateLimiterBasics(string endpoint1, string endpoint2, bool expectLimited)
         {
+            var log = new Log("Test");
+            log.Level = LogLevel.Trace;
+
             var rateLimiter = new RateLimiter();
             rateLimiter.AddTotalRateLimit(1, TimeSpan.FromSeconds(0.1));
 
-            var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint1, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
-            var result2 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint2, HttpMethod.Get, true, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            var result1 = await rateLimiter.LimitRequestAsync(log, endpoint1, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            var result2 = await rateLimiter.LimitRequestAsync(log, endpoint2, HttpMethod.Get, true, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
             Assert.IsTrue(result1.Data == 0);
             Assert.IsTrue(expectLimited ? result2.Data > 0 : result2.Data == 0);
         }
@@ -312,12 +350,15 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase("/sapi/test", true, true, false, true)]
         public async Task ApiKeyRateLimiterIgnores_TotalRateLimiter_IfSet(string endpoint, bool signed1, bool signed2, bool ignoreTotal, bool expectLimited)
         {
+            var log = new Log("Test");
+            log.Level = LogLevel.Trace;
+
             var rateLimiter = new RateLimiter();
             rateLimiter.AddApiKeyLimit(100, TimeSpan.FromSeconds(0.1), true, ignoreTotal);
             rateLimiter.AddTotalRateLimit(1, TimeSpan.FromSeconds(0.1));
 
-            var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint, HttpMethod.Get, signed1, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
-            var result2 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint, HttpMethod.Get, signed2, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            var result1 = await rateLimiter.LimitRequestAsync(log, endpoint, HttpMethod.Get, signed1, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            var result2 = await rateLimiter.LimitRequestAsync(log, endpoint, HttpMethod.Get, signed2, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
             Assert.IsTrue(result1.Data == 0);
             Assert.IsTrue(expectLimited ? result2.Data > 0 : result2.Data == 0);
         }

CryptoExchange.Net.UnitTests/SocketClientTests.cs

@@ -17,16 +17,19 @@ namespace CryptoExchange.Net.UnitTests
         {
             //arrange
             //act
-            var client = new TestSocketClient(options =>
+            var client = new TestSocketClient(new TestOptions()
             {
-                options.SubOptions.ApiCredentials = new Authentication.ApiCredentials("1", "2");
-                options.SubOptions.MaxSocketConnections = 1;
+                SubOptions = new RestApiClientOptions
+                {
+                    BaseAddress = "http://test.address.com"
+                },
+                ReconnectInterval = TimeSpan.FromSeconds(6)
             });
 
 
             //assert
-            Assert.NotNull(client.SubClient.ApiOptions.ApiCredentials);
-            Assert.AreEqual(1, client.SubClient.ApiOptions.MaxSocketConnections);
+            Assert.IsTrue(client.SubClient.Options.BaseAddress == "http://test.address.com");
+            Assert.IsTrue(client.ClientOptions.ReconnectInterval.TotalSeconds == 6);
         }
 
         [TestCase(true)]
@@ -39,7 +42,7 @@ namespace CryptoExchange.Net.UnitTests
             socket.CanConnect = canConnect;
 
             //act
-            var connectResult = client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), client.SubClient, socket, null));
+            var connectResult = client.ConnectSocketSub(new SocketConnection(client, null, socket));
 
             //assert
             Assert.IsTrue(connectResult.Success == canConnect);
@@ -49,22 +52,20 @@ namespace CryptoExchange.Net.UnitTests
         public void SocketMessages_Should_BeProcessedInDataHandlers()
         {
             // arrange
-            var client = new TestSocketClient(options => {
-                options.ReconnectInterval = TimeSpan.Zero;
-            });
+            var client = new TestSocketClient(new TestOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
             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, null, socket);
             var rstEvent = new ManualResetEvent(false);
             JToken result = null;
-            sub.AddSubscription(SocketSubscription.CreateForIdentifier(10, "TestHandler", true, false, (messageEvent) =>
+            sub.AddSubscription(SocketSubscription.CreateForIdentifier(10, "TestHandler", true, (messageEvent) =>
             {
                 result = messageEvent.JsonData;
                 rstEvent.Set();
             }));
-            client.SubClient.ConnectSocketSub(sub);
+            client.ConnectSocketSub(sub);
 
             // act
             socket.InvokeMessage("{\"property\": 123}");
@@ -79,23 +80,20 @@ namespace CryptoExchange.Net.UnitTests
         public void SocketMessages_Should_ContainOriginalDataIfEnabled(bool enabled)
         {
             // arrange
-            var client = new TestSocketClient(options => {
-                options.ReconnectInterval = TimeSpan.Zero;
-                options.SubOptions.OutputOriginalData = enabled;
-            });
+            var client = new TestSocketClient(new TestOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug, 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, null, socket);
             var rstEvent = new ManualResetEvent(false);
             string original = null;
-            sub.AddSubscription(SocketSubscription.CreateForIdentifier(10, "TestHandler", true, false, (messageEvent) =>
+            sub.AddSubscription(SocketSubscription.CreateForIdentifier(10, "TestHandler", true, (messageEvent) =>
             {
                 original = messageEvent.OriginalData;
                 rstEvent.Set();
             }));
-            client.SubClient.ConnectSocketSub(sub);
+            client.ConnectSocketSub(sub);
 
             // act
             socket.InvokeMessage("{\"property\": 123}");
@@ -105,20 +103,44 @@ namespace CryptoExchange.Net.UnitTests
             Assert.IsTrue(original == (enabled ? "{\"property\": 123}" : null));
         }
 
+        [TestCase]
+        public void DisconnectedSocket_Should_Reconnect()
+        {
+            // arrange
+            bool reconnected = false;
+            var client = new TestSocketClient(new TestOptions() { 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, null, 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(options => {
-                options.ReconnectInterval = TimeSpan.Zero;
-            }); 
+            var client = new TestSocketClient(new TestOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
             var socket = client.CreateSocket();
             socket.CanConnect = true;
-            var sub = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
-            client.SubClient.ConnectSocketSub(sub);
-            var us = SocketSubscription.CreateForIdentifier(10, "Test", true, false, (e) => { });
-            var ups = new UpdateSubscription(sub, us);
-            sub.AddSubscription(us);
+            var sub = new SocketConnection(client, null, socket);
+            client.ConnectSocketSub(sub);
+            var ups = new UpdateSubscription(sub, SocketSubscription.CreateForIdentifier(10, "Test", true, (e) => {}));
 
             // act
             client.UnsubscribeAsync(ups).Wait();
@@ -131,21 +153,15 @@ namespace CryptoExchange.Net.UnitTests
         public void UnsubscribingAll_Should_CloseAllSockets()
         {
             // arrange
-            var client = new TestSocketClient(options => { options.ReconnectInterval = TimeSpan.Zero; });
+            var client = new TestSocketClient(new TestOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
             var socket1 = client.CreateSocket();
             var socket2 = client.CreateSocket();
             socket1.CanConnect = true;
             socket2.CanConnect = true;
-            var sub1 = new SocketConnection(new TraceLogger(), client.SubClient, socket1, null);
-            var sub2 = new SocketConnection(new TraceLogger(), client.SubClient, socket2, null);
-            client.SubClient.ConnectSocketSub(sub1);
-            client.SubClient.ConnectSocketSub(sub2);
-            var us1 = SocketSubscription.CreateForIdentifier(10, "Test1", true, false, (e) => { });
-            var us2 = SocketSubscription.CreateForIdentifier(11, "Test2", true, false, (e) => { });
-            sub1.AddSubscription(us1);
-            sub2.AddSubscription(us2);
-            var ups1 = new UpdateSubscription(sub1, us1);
-            var ups2 = new UpdateSubscription(sub2, us2);
+            var sub1 = new SocketConnection(client, null, socket1);
+            var sub2 = new SocketConnection(client, null, socket2);
+            client.ConnectSocketSub(sub1);
+            client.ConnectSocketSub(sub2);
 
             // act
             client.UnsubscribeAllAsync().Wait();
@@ -159,13 +175,13 @@ namespace CryptoExchange.Net.UnitTests
         public void FailingToConnectSocket_Should_ReturnError()
         {
             // arrange
-            var client = new TestSocketClient(options => { options.ReconnectInterval = TimeSpan.Zero; });
+            var client = new TestSocketClient(new TestOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
             var socket = client.CreateSocket();
             socket.CanConnect = false;
-            var sub1 = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
+            var sub = new SocketConnection(client, null, socket);
 
             // act
-            var connectResult = client.SubClient.ConnectSocketSub(sub1);
+            var connectResult = client.ConnectSocketSub(sub);
 
             // assert
             Assert.IsFalse(connectResult.Success);

CryptoExchange.Net.UnitTests/SymbolOrderBookTests.cs

@@ -4,7 +4,6 @@ using System.Threading;
 using System.Threading.Tasks;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.OrderBook;
 using CryptoExchange.Net.Sockets;
 using NUnit.Framework;
@@ -18,9 +17,8 @@ namespace CryptoExchange.Net.UnitTests
 
         private class TestableSymbolOrderBook : SymbolOrderBook
         {
-            public TestableSymbolOrderBook() : base(null, "Test", "BTC/USD")
+            public TestableSymbolOrderBook() : base("Test", "BTC/USD", defaultOrderBookOptions)
             {
-                Initialize(defaultOrderBookOptions);
             }
 
 
@@ -37,12 +35,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._asks.Clear();
+                    base.bids.Add(bid.Price, bid);
+                base.asks.Clear();
                 foreach (var ask in asks)
-                    base._asks.Add(ask.Price, ask);
+                    base.asks.Add(ask.Price, ask);
             }
         }
 
@@ -110,33 +108,5 @@ namespace CryptoExchange.Net.UnitTests
             Assert.AreEqual(1.06666667m, resultBids2.Data);
             Assert.AreEqual(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.True(resultBids.Success);
-            Assert.True(resultAsks.Success);
-            Assert.AreEqual(1.9m, resultBids.Data);
-            Assert.AreEqual(1.61538462m, resultAsks.Data);
-            Assert.AreEqual(1.4m, resultBids2.Data);
-            Assert.AreEqual(1.23076923m, resultAsks2.Data);
-        }
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/TestBaseClient.cs

@@ -1,50 +1,31 @@
 using System;
 using System.Collections.Generic;
 using System.Net.Http;
-using System.Threading.Tasks;
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
-using CryptoExchange.Net.UnitTests.TestImplementations;
 using Microsoft.Extensions.Logging;
 
 namespace CryptoExchange.Net.UnitTests
 {
     public class TestBaseClient: BaseClient
     {       
-        public TestSubClient SubClient { get; }
-
-        public TestBaseClient(): base(null, "Test")
+        public TestBaseClient(): base("Test", new BaseClientOptions())
         {
-            var options = TestClientOptions.Default.Copy();
-            Initialize(options);
-            SubClient = AddApiClient(new TestSubClient(options, new RestApiOptions()));
         }
 
-        public TestBaseClient(TestClientOptions exchangeOptions) : base(null, "Test")
+        public TestBaseClient(BaseRestClientOptions exchangeOptions) : base("Test", exchangeOptions)
         {
-            Initialize(exchangeOptions);
-            SubClient = AddApiClient(new TestSubClient(exchangeOptions, new RestApiOptions()));
         }
 
         public void Log(LogLevel verbosity, string data)
         {
-            _logger.Log(verbosity, data);
+            log.Write(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, null, null);
         }
-
-        public CallResult<T> Deserialize<T>(string data) => Deserialize<T>(data, null, null);
-
-        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
@@ -64,8 +45,5 @@ namespace CryptoExchange.Net.UnitTests
         {
             return toSign;
         }
-
-        public string GetKey() => _credentials.Key.GetString();
-        public string GetSecret() => _credentials.Secret.GetString();
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/TestRestClient.cs

@@ -12,8 +12,6 @@ using System.Threading;
 using System.Threading.Tasks;
 using CryptoExchange.Net.Authentication;
 using System.Collections.Generic;
-using CryptoExchange.Net.Objects.Options;
-using Microsoft.Extensions.Logging;
 
 namespace CryptoExchange.Net.UnitTests.TestImplementations
 {
@@ -22,22 +20,15 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
         public TestRestApi1Client Api1 { get; }
         public TestRestApi2Client Api2 { get; }
 
-        public TestRestClient(Action<TestClientOptions> optionsFunc) : this(optionsFunc, null)
+        public TestRestClient() : this(new TestClientOptions())
         {
         }
 
-        public TestRestClient(ILoggerFactory loggerFactory = null, HttpClient httpClient = null) : this((x) => { }, httpClient, loggerFactory)
+        public TestRestClient(TestClientOptions exchangeOptions) : base("Test", exchangeOptions)
         {
-        }
-
-        public TestRestClient(Action<TestClientOptions> optionsFunc, HttpClient httpClient = null, ILoggerFactory loggerFactory = null) : base(loggerFactory, "Test")
-        {
-            var options = TestClientOptions.Default.Copy();
-            optionsFunc(options);
-            Initialize(options);
-
-            Api1 = new TestRestApi1Client(options);
-            Api2 = new TestRestApi2Client(options);
+            Api1 = new TestRestApi1Client(exchangeOptions);
+            Api2 = new TestRestApi2Client(exchangeOptions);
+            RequestFactory = new Mock<IRequestFactory>().Object;
         }
 
         public void SetResponse(string responseData, out IRequest requestObj)
@@ -59,7 +50,7 @@ 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(Api1.RequestFactory);
+            var factory = Mock.Get(RequestFactory);
             factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
                 .Callback<HttpMethod, Uri, int>((method, uri, id) => 
                 { 
@@ -67,15 +58,6 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
                     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;
         }
 
@@ -89,12 +71,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             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(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Returns(request.Object);
-
-
-            factory = Mock.Get(Api2.RequestFactory);
+            var factory = Mock.Get(RequestFactory);
             factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
                 .Returns(request.Object);
         }
@@ -117,33 +94,27 @@ 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(Api1.RequestFactory);
+            var factory = Mock.Get(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);
+        }
 
-            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
+        {
+            return await SendRequestAsync<T>(Api1, new Uri("http://www.test.com"), HttpMethod.Get, ct);
+        }
+
+        public async Task<CallResult<T>> RequestWithParams<T>(HttpMethod method, Dictionary<string, object> parameters, Dictionary<string, string> headers) where T : class
+        {
+            return await SendRequestAsync<T>(Api1, new Uri("http://www.test.com"), method, default, parameters, additionalHeaders: headers);
         }
     }
 
     public class TestRestApi1Client : RestApiClient
     {
-        public TestRestApi1Client(TestClientOptions options) : base(new TraceLogger(), null, "https://localhost:123", options, options.Api1Options)
+        public TestRestApi1Client(TestClientOptions options): base(options, options.Api1Options)
         {
-            RequestFactory = new Mock<IRequestFactory>().Object;
-        }
-
-        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);
-        }
-
-        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);
         }
 
         public void SetParameterPosition(HttpMethod method, HttpMethodParameterPosition position)
@@ -151,7 +122,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             ParameterPositions[method] = position;
         }
 
-        public override TimeSpan? GetTimeOffset()
+        public override TimeSpan GetTimeOffset()
         {
             throw new NotImplementedException();
         }
@@ -172,24 +143,12 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
 
     public class TestRestApi2Client : RestApiClient
     {
-        public TestRestApi2Client(TestClientOptions options) : base(new TraceLogger(), null, "https://localhost:123", options, options.Api2Options)
+        public TestRestApi2Client(TestClientOptions options) : base(options, options.Api2Options)
         {
-            RequestFactory = new Mock<IRequestFactory>().Object;
+
         }
 
-        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);
-        }
-
-        protected override Error ParseErrorResponse(int httpStatusCode, IEnumerable<KeyValuePair<string, IEnumerable<string>>> responseHeaders, string data)
-        {
-            var errorData = ValidateJson(data);
-
-            return new ServerError((int)errorData.Data["errorCode"], (string)errorData.Data["errorMessage"]);
-        }
-
-        public override TimeSpan? GetTimeOffset()
+        public override TimeSpan GetTimeOffset()
         {
             throw new NotImplementedException();
         }
@@ -208,9 +167,28 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
         }
     }
 
+    public class TestAuthProvider : AuthenticationProvider
+    {
+        public TestAuthProvider(ApiCredentials credentials) : base(credentials)
+        {
+        }
+
+        public override void AuthenticateRequest(RestApiClient apiClient, Uri uri, HttpMethod method, Dictionary<string, object> providedParameters, bool auth, ArrayParametersSerialization arraySerialization, HttpMethodParameterPosition parameterPosition, out SortedDictionary<string, object> uriParameters, out SortedDictionary<string, object> bodyParameters, out Dictionary<string, string> headers)
+        {
+            uriParameters = parameterPosition == HttpMethodParameterPosition.InUri ? new SortedDictionary<string, object>(providedParameters) : new SortedDictionary<string, object>();
+            bodyParameters = parameterPosition == HttpMethodParameterPosition.InBody ? new SortedDictionary<string, object>(providedParameters) : new SortedDictionary<string, object>();
+            headers = new Dictionary<string, string>();
+        }
+    }
+
     public class ParseErrorTestRestClient: TestRestClient
     {
         public ParseErrorTestRestClient() { }
+        public ParseErrorTestRestClient(TestClientOptions exchangeOptions) : base(exchangeOptions) { }
 
+        protected override Error ParseErrorResponse(JToken error)
+        {
+            return new ServerError((int)error["errorCode"], (string)error["errorMessage"]);
+        }
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/TestSocket.cs

@@ -13,16 +13,9 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
         public bool Connected { get; set; }
 
         public event Action OnClose;
-
-#pragma warning disable 0067
-        public event Action OnReconnected;
-        public event Action OnReconnecting;
-#pragma warning restore 0067
-        public event Action<int> OnRequestSent;
         public event Action<string> OnMessage;
         public event Action<Exception> OnError;
         public event Action OnOpen;
-        public Func<Task<Uri>> GetReconnectionUrl { get; set; }
 
         public int Id { get; }
         public bool ShouldReconnect { get; set; }
@@ -70,11 +63,10 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             return Task.FromResult(CanConnect);
         }
 
-        public void Send(int requestId, string data, int weight)
+        public void Send(string data)
         {
             if(!Connected)
                 throw new Exception("Socket not connected");
-            OnRequestSent?.Invoke(requestId);
         }
 
         public void Reset()
@@ -101,7 +93,6 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
         {
             Connected = false;
             DisconnectTime = DateTime.UtcNow;
-            Reconnecting = true;
             OnClose?.Invoke();
         }
 
@@ -124,6 +115,11 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
         {
             OnError?.Invoke(error);
         }
-        public Task ReconnectAsync() => Task.CompletedTask;
+
+        public async Task ProcessAsync()
+        {
+            while (Connected)
+                await Task.Delay(50);
+        }
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/TestSocketClient.cs

@@ -1,12 +1,10 @@
 using System;
-using System.Collections.Generic;
 using System.Threading.Tasks;
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Logging;
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.Sockets;
-using Microsoft.Extensions.Logging;
 using Moq;
 using Newtonsoft.Json.Linq;
 
@@ -16,72 +14,22 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
     {
         public TestSubSocketClient SubClient { get; }
 
-        public TestSocketClient(ILoggerFactory loggerFactory = null) : this((x) => { }, loggerFactory)
+        public TestSocketClient() : this(new TestOptions())
         {
         }
 
-        /// <summary>
-        /// Create a new instance of KucoinSocketClient
-        /// </summary>
-        /// <param name="optionsFunc">Configure the options to use for this client</param>
-        public TestSocketClient(Action<TestSocketOptions> optionsFunc) : this(optionsFunc, null)
+        public TestSocketClient(TestOptions exchangeOptions) : base("test", exchangeOptions)
         {
-        }
-
-        public TestSocketClient(Action<TestSocketOptions> optionsFunc, ILoggerFactory loggerFactory = null) : base(loggerFactory, "Test")
-        {
-            var options = TestSocketOptions.Default.Copy<TestSocketOptions>();
-            optionsFunc(options);
-            Initialize(options);
-
-            SubClient = AddApiClient(new TestSubSocketClient(options, options.SubOptions));
-            SubClient.SocketFactory = new Mock<IWebsocketFactory>().Object;
-            Mock.Get(SubClient.SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<ILogger>(), It.IsAny<WebSocketParameters>())).Returns(new TestSocket());
+            SubClient = new TestSubSocketClient(exchangeOptions, exchangeOptions.SubOptions);
+            SocketFactory = new Mock<IWebsocketFactory>().Object;
+            Mock.Get(SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<Log>(), It.IsAny<string>())).Returns(new TestSocket());
         }
 
         public TestSocket CreateSocket()
         {
-            Mock.Get(SubClient.SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<ILogger>(), It.IsAny<WebSocketParameters>())).Returns(new TestSocket());
-            return (TestSocket)SubClient.CreateSocketInternal("https://localhost:123/");
+            Mock.Get(SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<Log>(), It.IsAny<string>())).Returns(new TestSocket());
+            return (TestSocket)CreateSocket("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")
-        };
-
-        public SocketApiOptions SubOptions { get; set; } = new SocketApiOptions();
-    }
-
-    public class TestSubSocketClient : SocketApiClient
-    {
-
-        public TestSubSocketClient(TestSocketOptions options, SocketApiOptions apiOptions): base(new TraceLogger(), options.Environment.TestAddress, options, apiOptions)
-        {
-
-        }
-
-        internal IWebsocket CreateSocketInternal(string address)
-        {
-            return CreateSocket(address);
-        }
-
-        protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials)
-            => new TestAuthProvider(credentials);
 
         public CallResult<bool> ConnectSocketSub(SocketConnection sub)
         {
@@ -119,4 +67,21 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             throw new NotImplementedException();
         }
     }
+
+    public class TestOptions: BaseSocketClientOptions
+    {
+        public ApiClientOptions SubOptions { get; set; } = new ApiClientOptions();
+    }
+
+    public class TestSubSocketClient : SocketApiClient
+    {
+
+        public TestSubSocketClient(BaseClientOptions options, ApiClientOptions apiOptions): base(options, apiOptions)
+        {
+
+        }
+
+        protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials)
+            => new TestAuthProvider(credentials);
+    }
 }

CryptoExchange.Net.UnitTests/TestImplementations/TestStringLogger.cs

@@ -0,0 +1,25 @@
+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/AssemblyInfo.cs

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

CryptoExchange.Net/Authentication/ApiCredentials.cs

@@ -22,17 +22,17 @@ namespace CryptoExchange.Net.Authentication
         public SecureString? Secret { get; }
 
         /// <summary>
-        /// Type of the credentials
+        /// The private key to authenticate requests
         /// </summary>
-        public ApiCredentialsType CredentialType { get; }
+        public PrivateKey? PrivateKey { get; }
 
         /// <summary>
-        /// Create Api credentials providing an api key and secret for authentication
+        /// Create Api credentials providing a private key 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(SecureString key, SecureString secret) : this(key, secret, ApiCredentialsType.Hmac)
+        /// <param name="privateKey">The private key used for signing</param>
+        public ApiCredentials(PrivateKey privateKey)
         {
+            PrivateKey = privateKey;
         }
 
         /// <summary>
@@ -40,13 +40,11 @@ namespace CryptoExchange.Net.Authentication
         /// </summary>
         /// <param name="key">The api key used for identification</param>
         /// <param name="secret">The api secret used for signing</param>
-        /// <param name="credentialsType">The type of credentials</param>
-        public ApiCredentials(SecureString key, SecureString secret, ApiCredentialsType credentialsType)
+        public ApiCredentials(SecureString key, SecureString secret)
         {
             if (key == null || secret == null)
                 throw new ArgumentException("Key and secret can't be null/empty");
 
-            CredentialType = credentialsType;
             Key = key;
             Secret = secret;
         }
@@ -56,22 +54,11 @@ namespace CryptoExchange.Net.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) : this(key, secret, ApiCredentialsType.Hmac)
-        {
-        }
-
-        /// <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>
-        /// <param name="credentialsType">The type of credentials</param>
-        public ApiCredentials(string key, string secret, ApiCredentialsType credentialsType)
+        public ApiCredentials(string key, string secret)
         {
             if (string.IsNullOrEmpty(key) || string.IsNullOrEmpty(secret))
                 throw new ArgumentException("Key and secret can't be null/empty");
 
-            CredentialType = credentialsType;
             Key = key.ToSecureString();
             Secret = secret.ToSecureString();
         }
@@ -82,8 +69,11 @@ namespace CryptoExchange.Net.Authentication
         /// <returns></returns>
         public virtual ApiCredentials Copy()
         {
-            // Use .GetString() to create a copy of the SecureString
-            return new ApiCredentials(Key!.GetString(), Secret!.GetString(), CredentialType);
+            if (PrivateKey == null)
+                // Use .GetString() to create a copy of the SecureString
+                return new ApiCredentials(Key!.GetString(), Secret!.GetString());
+            else
+                return new ApiCredentials(PrivateKey!.Copy());
         }
 
         /// <summary>
@@ -133,6 +123,7 @@ namespace CryptoExchange.Net.Authentication
         {
             Key?.Dispose();
             Secret?.Dispose();
+            PrivateKey?.Dispose();
         }
     }
 }

CryptoExchange.Net/Authentication/ApiCredentialsType.cs

@@ -1,21 +0,0 @@
-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

@@ -12,15 +12,14 @@ namespace CryptoExchange.Net.Authentication
     /// <summary>
     /// Base class for authentication providers
     /// </summary>
-    public abstract class AuthenticationProvider : IDisposable
+    public abstract class AuthenticationProvider
     {
         /// <summary>
-        /// Provided credentials
+        /// The provided credentials
         /// </summary>
-        protected readonly ApiCredentials _credentials;
+        public ApiCredentials Credentials { get; }
 
         /// <summary>
-        /// Byte representation of the secret
         /// </summary>
         protected byte[] _sBytes;
 
@@ -33,7 +32,7 @@ namespace CryptoExchange.Net.Authentication
             if (credentials.Secret == null)
                 throw new ArgumentException("ApiKey/Secret needed");
 
-            _credentials = credentials;
+            Credentials = credentials;
             _sBytes = Encoding.UTF8.GetBytes(credentials.Secret.GetString());
         }
 
@@ -84,7 +83,7 @@ namespace CryptoExchange.Net.Authentication
         {
             using var encryptor = SHA256.Create();
             var resultBytes = encryptor.ComputeHash(Encoding.UTF8.GetBytes(data));
-            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes): BytesToHexString(resultBytes);
         }
 
         /// <summary>
@@ -174,47 +173,6 @@ namespace CryptoExchange.Net.Authentication
             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 = RSA.Create();
-            if (_credentials.CredentialType == ApiCredentialsType.RsaPem)
-            {
-#if NETSTANDARD2_1_OR_GREATER
-                // Read from pem private key
-                var key = _credentials.Secret!.GetString()
-                        .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!.GetString());
-            }
-            else
-            {
-                throw new Exception("Invalid credentials type");
-            }
-
-            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>
         /// Sign a string
         /// </summary>
@@ -265,7 +223,7 @@ namespace CryptoExchange.Net.Authentication
         /// <returns></returns>
         protected static DateTime GetTimestamp(RestApiClient apiClient)
         {
-            return DateTime.UtcNow.Add(apiClient.GetTimeOffset() ?? TimeSpan.Zero)!;
+            return DateTime.UtcNow.Add(apiClient?.GetTimeOffset() ?? TimeSpan.Zero)!;
         }
 
         /// <summary>
@@ -277,26 +235,5 @@ namespace CryptoExchange.Net.Authentication
         {
             return DateTimeConverter.ConvertToMilliseconds(GetTimestamp(apiClient)).Value.ToString(CultureInfo.InvariantCulture);
         }
-
-        /// <inheritdoc />
-        public void Dispose()
-        {
-            _credentials?.Dispose();
-        }
-    }
-
-    /// <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

@@ -0,0 +1,110 @@
+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/Clients/BaseApiClient.cs

@@ -1,40 +1,37 @@
 using System;
 using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
-using System.Net;
 using System.Net.Http;
-using System.Text;
-using System.Threading.Tasks;
 using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
-using Microsoft.Extensions.Logging;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 
 namespace CryptoExchange.Net
 {
     /// <summary>
     /// Base API for all API clients
     /// </summary>
-    public abstract class BaseApiClient : IDisposable, IBaseApiClient
+    public abstract class BaseApiClient: IDisposable
     {
-        /// <summary>
-        /// Logger
-        /// </summary>
-        protected ILogger _logger;
-
-        /// <summary>
-        /// If we are disposing
-        /// </summary>
-        protected bool _disposing;
+        private ApiCredentials? _apiCredentials;
+        private AuthenticationProvider? _authenticationProvider;
+        private bool _created;
+        private bool _disposing;
 
         /// <summary>
         /// The authentication provider for this API client. (null if no credentials are set)
         /// </summary>
-        public AuthenticationProvider? AuthenticationProvider { get; private set; }
+        public AuthenticationProvider? AuthenticationProvider
+        {
+            get 
+            {
+                if (!_created && !_disposing && _apiCredentials != null)
+                {
+                    _authenticationProvider = CreateAuthenticationProvider(_apiCredentials);
+                    _created = true;
+                }
+
+                return _authenticationProvider;
+            }
+        }
 
         /// <summary>
         /// Where to put the parameters for requests with different Http methods
@@ -68,57 +65,25 @@ namespace CryptoExchange.Net
         public string requestBodyEmptyContent = "{}";
 
         /// <summary>
-        /// The environment this client communicates to
+        /// The base address for this API client
         /// </summary>
-        public string BaseAddress { get; }
+        internal protected string BaseAddress { get; }
 
         /// <summary>
-        /// Output the original string data along with the deserialized object
+        /// Api client options
         /// </summary>
-        public bool OutputOriginalData { get; }
-
-        /// <summary>
-        /// A default serializer
-        /// </summary>
-        private static readonly JsonSerializer _defaultSerializer = JsonSerializer.Create(new JsonSerializerSettings
-        {
-            DateTimeZoneHandling = DateTimeZoneHandling.Utc,
-            Culture = CultureInfo.InvariantCulture
-        });
-
-        /// <summary>
-        /// Api options
-        /// </summary>
-        public ApiOptions ApiOptions { get; }
-
-        /// <summary>
-        /// Client Options
-        /// </summary>
-        public ExchangeOptions ClientOptions { get; }
+        internal ApiClientOptions Options { 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)
+        /// <param name="options">Client options</param>
+        /// <param name="apiOptions">Api client options</param>
+        protected BaseApiClient(BaseClientOptions options, ApiClientOptions apiOptions)
         {
-            _logger = logger;
-
-            ClientOptions = clientOptions;
-            ApiOptions = apiOptions;
-            OutputOriginalData = outputOriginalData;
-            BaseAddress = baseAddress;
-
-            if (apiCredentials != null)
-            {
-                AuthenticationProvider?.Dispose();
-                AuthenticationProvider = CreateAuthenticationProvider(apiCredentials.Copy());
-            }
+            Options = apiOptions;
+            _apiCredentials = apiOptions.ApiCredentials?.Copy() ?? options.ApiCredentials?.Copy();
+            BaseAddress = apiOptions.BaseAddress;
         }
 
         /// <summary>
@@ -129,213 +94,21 @@ namespace CryptoExchange.Net
         protected abstract AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials);
 
         /// <inheritdoc />
-        public void SetApiCredentials<T>(T credentials) where T : ApiCredentials
+        public void SetApiCredentials(ApiCredentials credentials)
         {
-            if (credentials != null)
-            {
-                AuthenticationProvider?.Dispose();
-                AuthenticationProvider = CreateAuthenticationProvider(credentials.Copy());
-            }
-        }
-
-        /// <summary>
-        /// Tries to parse the json data and return 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";
-                _logger.Log(LogLevel.Error, info);
-                return new CallResult<JToken>(new DeserializeError(info, data));
-            }
-
-            try
-            {
-                return new CallResult<JToken>(JToken.Parse(data));
-            }
-            catch (JsonReaderException jre)
-            {
-                var info = $"Deserialize JsonReaderException: {jre.Message}, Path: {jre.Path}, LineNumber: {jre.LineNumber}, LinePosition: {jre.LinePosition}";
-                return new CallResult<JToken>(new DeserializeError(info, data));
-            }
-            catch (JsonSerializationException jse)
-            {
-                var info = $"Deserialize JsonSerializationException: {jse.Message}";
-                return new CallResult<JToken>(new DeserializeError(info, data));
-            }
-            catch (Exception ex)
-            {
-                var exceptionInfo = ex.ToLogString();
-                var info = $"Deserialize Unknown Exception: {exceptionInfo}";
-                return new CallResult<JToken>(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="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, JsonSerializer? serializer = null, int? requestId = null)
-        {
-            var tokenResult = ValidateJson(data);
-            if (!tokenResult)
-            {
-                _logger.Log(LogLevel.Error, tokenResult.Error!.Message);
-                return new CallResult<T>(tokenResult.Error);
-            }
-
-            return Deserialize<T>(tokenResult.Data, 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="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, JsonSerializer? serializer = null, int? requestId = null)
-        {
-            serializer ??= _defaultSerializer;
-
-            try
-            {
-                return new CallResult<T>(obj.ToObject<T>(serializer)!);
-            }
-            catch (JsonReaderException jre)
-            {
-                var info = $"{(requestId != null ? $"[{requestId}] " : "")}Deserialize JsonReaderException: {jre.Message} Path: {jre.Path}, LineNumber: {jre.LineNumber}, LinePosition: {jre.LinePosition}, data: {obj}";
-                _logger.Log(LogLevel.Error, info);
-                return new CallResult<T>(new DeserializeError(info, obj));
-            }
-            catch (JsonSerializationException jse)
-            {
-                var info = $"{(requestId != null ? $"[{requestId}] " : "")}Deserialize JsonSerializationException: {jse.Message} data: {obj}";
-                _logger.Log(LogLevel.Error, info);
-                return new CallResult<T>(new DeserializeError(info, obj));
-            }
-            catch (Exception ex)
-            {
-                var exceptionInfo = ex.ToLogString();
-                var info = $"{(requestId != null ? $"[{requestId}] " : "")}Deserialize Unknown Exception: {exceptionInfo}, data: {obj}";
-                _logger.Log(LogLevel.Error, info);
-                return new CallResult<T>(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)
-        {
-            serializer ??= _defaultSerializer;
-            string? data = null;
-
-            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 == true)
-                {
-                    data = await reader.ReadToEndAsync().ConfigureAwait(false);
-                    _logger.Log(LogLevel.Debug, $"{(requestId != null ? $"[{requestId}] " : "")}Response received{(elapsedMilliseconds != null ? $" in {elapsedMilliseconds}" : " ")}ms: " + data);
-                    var result = Deserialize<T>(data, serializer, requestId);
-                    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);
-                _logger.Log(LogLevel.Debug, $"{(requestId != null ? $"[{requestId}] " : "")}Response received{(elapsedMilliseconds != null ? $" in {elapsedMilliseconds}" : " ")}ms");
-                return new CallResult<T>(serializer.Deserialize<T>(jsonReader)!);
-            }
-            catch (JsonReaderException jre)
-            {
-                if (data == null)
-                {
-                    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 Trace LogLevel]";
-                    }
-                }
-                _logger.Log(LogLevel.Error, $"{(requestId != null ? $"[{requestId}] " : "")}Deserialize JsonReaderException: {jre.Message}, Path: {jre.Path}, LineNumber: {jre.LineNumber}, LinePosition: {jre.LinePosition}, data: {data}");
-                return new CallResult<T>(new DeserializeError($"Deserialize JsonReaderException: {jre.Message}, Path: {jre.Path}, LineNumber: {jre.LineNumber}, LinePosition: {jre.LinePosition}", data));
-            }
-            catch (JsonSerializationException jse)
-            {
-                if (data == null)
-                {
-                    if (stream.CanSeek)
-                    {
-                        stream.Seek(0, SeekOrigin.Begin);
-                        data = await ReadStreamAsync(stream).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        data = "[Data only available in Trace LogLevel]";
-                    }
-                }
-
-                _logger.Log(LogLevel.Error, $"{(requestId != null ? $"[{requestId}] " : "")}Deserialize JsonSerializationException: {jse.Message}, data: {data}");
-                return new CallResult<T>(new DeserializeError($"Deserialize JsonSerializationException: {jse.Message}", data));
-            }
-            catch (Exception ex)
-            {
-                if (data == null)
-                {
-                    if (stream.CanSeek)
-                    {
-                        stream.Seek(0, SeekOrigin.Begin);
-                        data = await ReadStreamAsync(stream).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        data = "[Data only available in Trace LogLevel]";
-                    }
-                }
-
-                var exceptionInfo = ex.ToLogString();
-                _logger.Log(LogLevel.Error, $"{(requestId != null ? $"[{requestId}] " : "")}Deserialize Unknown Exception: {exceptionInfo}, data: {data}");
-                return new CallResult<T>(new DeserializeError($"Deserialize Unknown Exception: {exceptionInfo}", data));
-            }
-        }
-
-        private static async Task<string> ReadStreamAsync(Stream stream)
-        {
-            using var reader = new StreamReader(stream, Encoding.UTF8, false, 512, true);
-            return await reader.ReadToEndAsync().ConfigureAwait(false);
+            _apiCredentials = credentials?.Copy();
+            _created = false;
+            _authenticationProvider = null;
         }
 
         /// <summary>
         /// Dispose
         /// </summary>
-        public virtual void Dispose()
+        public void Dispose()
         {
             _disposing = true;
-            AuthenticationProvider?.Dispose();
+            _apiCredentials?.Dispose();
+            AuthenticationProvider?.Credentials?.Dispose();
         }
     }
 }

CryptoExchange.Net/Clients/BaseClient.cs

@@ -1,10 +1,15 @@
 using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Logging;
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Abstractions;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
 
 namespace CryptoExchange.Net
 {
@@ -17,58 +22,54 @@ namespace CryptoExchange.Net
         /// The name of the API the client is for
         /// </summary>
         internal string Name { 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;
-        
+        protected internal Log log;
+        /// <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>
         /// Provided client options
         /// </summary>
-        public ExchangeOptions ClientOptions { get; private set; }
+        public BaseClientOptions ClientOptions { get; }
 
         /// <summary>
         /// ctor
         /// </summary>
-        /// <param name="logger">Logger</param>
         /// <param name="name">The name of the API 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 name)
-#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        /// <param name="options">The options for this client</param>
+        protected BaseClient(string name, BaseClientOptions options)
         {
-            _logger = logger?.CreateLogger(name) ?? NullLoggerFactory.Instance.CreateLogger(name);
-
-            Name = name;
-        }
-
-        /// <summary>
-        /// Initialize the client with the specified options
-        /// </summary>
-        /// <param name="options"></param>
-        /// <exception cref="ArgumentNullException"></exception>
-        public virtual void Initialize(ExchangeOptions options)
-        {
-            if (options == null)
-                throw new ArgumentNullException(nameof(options));
+            log = new Log(name);
+            log.UpdateWriters(options.LogWriters);
+            log.Level = options.LogLevel;
+            options.OnLoggingChanged += HandleLogConfigChange;
 
             ClientOptions = options;
-            _logger.Log(LogLevel.Trace, $"Client configuration: {options}, CryptoExchange.Net: v{typeof(BaseClient).Assembly.GetName().Version}, {Name}.Net: v{GetType().Assembly.GetName().Version}");
-        }
 
-        /// <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);
+            Name = name;
+
+            log.Write(LogLevel.Trace, $"Client configuration: {options}, CryptoExchange.Net: v{typeof(BaseClient).Assembly.GetName().Version}, {name}.Net: v{GetType().Assembly.GetName().Version}");
         }
 
         /// <summary>
@@ -77,20 +78,227 @@ namespace CryptoExchange.Net
         /// <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}");
+            log.Write(LogLevel.Trace, $"  {apiClient.GetType().Name} configuration: {apiClient.Options}");
             ApiClients.Add(apiClient);
             return apiClient;
         }
 
+        /// <summary>
+        /// Tries to parse the json data and return 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>(new DeserializeError(info, data));
+            }
+
+            try
+            {
+                return new CallResult<JToken>(JToken.Parse(data));
+            }
+            catch (JsonReaderException jre)
+            {
+                var info = $"Deserialize JsonReaderException: {jre.Message}, Path: {jre.Path}, LineNumber: {jre.LineNumber}, LinePosition: {jre.LinePosition}";
+                return new CallResult<JToken>(new DeserializeError(info, data));
+            }
+            catch (JsonSerializationException jse)
+            {
+                var info = $"Deserialize JsonSerializationException: {jse.Message}";
+                return new CallResult<JToken>(new DeserializeError(info, data));
+            }
+            catch (Exception ex)
+            {
+                var exceptionInfo = ex.ToLogString();
+                var info = $"Deserialize Unknown Exception: {exceptionInfo}";
+                return new CallResult<JToken>(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="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, JsonSerializer? serializer = null, int? requestId = null)
+        {
+            var tokenResult = ValidateJson(data);
+            if (!tokenResult)
+            {
+                log.Write(LogLevel.Error, tokenResult.Error!.Message);
+                return new CallResult<T>( tokenResult.Error);
+            }
+
+            return Deserialize<T>(tokenResult.Data, 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="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, JsonSerializer? serializer = null, int? requestId = null)
+        {
+            serializer ??= defaultSerializer;
+
+            try
+            {
+                return new CallResult<T>(obj.ToObject<T>(serializer)!);
+            }
+            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>(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>(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>(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)
+        {
+            serializer ??= defaultSerializer;
+            string? data = null;
+
+            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 (ClientOptions.OutputOriginalData || log.Level == LogLevel.Trace)
+                {
+                    data = await reader.ReadToEndAsync().ConfigureAwait(false);
+                    log.Write(LogLevel.Debug, $"{(requestId != null ? $"[{requestId}] ": "")}Response received{(elapsedMilliseconds != null ? $" in {elapsedMilliseconds}" : " ")}ms{(log.Level == LogLevel.Trace ? (": " + data) : "")}");
+                    var result = Deserialize<T>(data, serializer, requestId);
+                    if(ClientOptions.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);
+                log.Write(LogLevel.Debug, $"{(requestId != null ? $"[{requestId}] ": "")}Response received{(elapsedMilliseconds != null ? $" in {elapsedMilliseconds}" : " ")}ms");
+                return new CallResult<T>(serializer.Deserialize<T>(jsonReader)!);
+            }
+            catch (JsonReaderException jre)
+            {
+                if (data == null)
+                {
+                    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 Trace 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>(new DeserializeError($"Deserialize JsonReaderException: {jre.Message}, Path: {jre.Path}, LineNumber: {jre.LineNumber}, LinePosition: {jre.LinePosition}", data));
+            }
+            catch (JsonSerializationException jse)
+            {
+                if (data == null)
+                {
+                    if (stream.CanSeek)
+                    {
+                        stream.Seek(0, SeekOrigin.Begin);
+                        data = await ReadStreamAsync(stream).ConfigureAwait(false);
+                    }
+                    else
+                        data = "[Data only available in Trace LogLevel]";
+                }
+
+                log.Write(LogLevel.Error, $"{(requestId != null ? $"[{requestId}] " : "")}Deserialize JsonSerializationException: {jse.Message}, data: {data}");
+                return new CallResult<T>(new DeserializeError($"Deserialize JsonSerializationException: {jse.Message}", data));
+            }
+            catch (Exception ex)
+            {
+                if (data == null)
+                {
+                    if (stream.CanSeek)
+                    {
+                        stream.Seek(0, SeekOrigin.Begin);
+                        data = await ReadStreamAsync(stream).ConfigureAwait(false);
+                    }
+                    else
+                        data = "[Data only available in Trace LogLevel]";
+                }
+
+                var exceptionInfo = ex.ToLogString();
+                log.Write(LogLevel.Error, $"{(requestId != null ? $"[{requestId}] " : "")}Deserialize Unknown Exception: {exceptionInfo}, data: {data}");
+                return new CallResult<T>(new DeserializeError($"Deserialize Unknown Exception: {exceptionInfo}", data));
+            }
+        }
+
+        private static async Task<string> ReadStreamAsync(Stream stream)
+        { 
+            using var reader = new StreamReader(stream, Encoding.UTF8, false, 512, true);
+            return await reader.ReadToEndAsync().ConfigureAwait(false);
+        }
+
+        /// <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 static int NextId()
+        {
+            lock (idLock)
+            {
+                lastId += 1;
+                return lastId;
+            }
+        }
+
+        /// <summary>
+        /// Handle a change in the client options log config
+        /// </summary>
+        private void HandleLogConfigChange()
+        {
+            log.UpdateWriters(ClientOptions.LogWriters);
+            log.Level = ClientOptions.LogLevel;
+        }
+
         /// <summary>
         /// Dispose
         /// </summary>
         public virtual void Dispose()
         {
-            _logger.Log(LogLevel.Debug, "Disposing client");
+            log.Write(LogLevel.Debug, "Disposing client");
+            ClientOptions.OnLoggingChanged -= HandleLogConfigChange;
             foreach (var client in ApiClients)
                 client.Dispose();
         }

CryptoExchange.Net/Clients/BaseRestClient.cs

@@ -1,6 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
 using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Requests;
 using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace CryptoExchange.Net
 {
@@ -9,16 +22,475 @@ namespace CryptoExchange.Net
     /// </summary>
     public abstract class BaseRestClient : BaseClient, IRestClient
     {
+        /// <summary>
+        /// The factory for creating requests. Used for unit testing
+        /// </summary>
+        public IRequestFactory RequestFactory { get; set; } = new RequestFactory();
+        
         /// <inheritdoc />
         public int TotalRequestsMade => ApiClients.OfType<RestApiClient>().Sum(s => s.TotalRequestsMade);
 
+        /// <summary>
+        /// Request headers to be sent with each request
+        /// </summary>
+        protected Dictionary<string, string>? StandardRequestHeaders { get; set; }
+
+        /// <summary>
+        /// Client options
+        /// </summary>
+        public new BaseRestClientOptions ClientOptions { get; }
+
         /// <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)
+        /// <param name="options">The options for this client</param>
+        protected BaseRestClient(string name, BaseRestClientOptions options) : base(name, options)
         {
+            if (options == null)
+                throw new ArgumentNullException(nameof(options));
+
+            ClientOptions = options;
+            RequestFactory.Configure(options.RequestTimeout, options.Proxy, options.HttpClient);
+        }
+
+        /// <inheritdoc />
+        public void SetApiCredentials(ApiCredentials credentials)
+        {
+            foreach (var apiClient in ApiClients)
+                apiClient.SetApiCredentials(credentials);
+        }
+
+        /// <summary>
+        /// Execute a request to the uri and returns if it was successful
+        /// </summary>
+        /// <param name="apiClient">The API client the request is for</param>
+        /// <param name="uri">The uri to send the request to</param>
+        /// <param name="method">The method of the request</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <param name="parameters">The parameters of the request</param>
+        /// <param name="signed">Whether or not the request should be authenticated</param>
+        /// <param name="parameterPosition">Where the parameters should be placed, overwrites the value set in the client</param>
+        /// <param name="arraySerialization">How array parameters should be serialized, overwrites the value set in the client</param>
+        /// <param name="requestWeight">Credits used for the request</param>
+        /// <param name="deserializer">The JsonSerializer to use for deserialization</param>
+        /// <param name="additionalHeaders">Additional headers to send with the request</param>
+        /// <param name="ignoreRatelimit">Ignore rate limits for this request</param>
+        /// <returns></returns>
+        [return: NotNull]
+        protected virtual async Task<WebCallResult> SendRequestAsync(RestApiClient apiClient,
+            Uri uri,
+            HttpMethod method,
+            CancellationToken cancellationToken,
+            Dictionary<string, object>? parameters = null,
+            bool signed = false,
+            HttpMethodParameterPosition? parameterPosition = null,
+            ArrayParametersSerialization? arraySerialization = null,
+            int requestWeight = 1,
+            JsonSerializer? deserializer = null,
+            Dictionary<string, string>? additionalHeaders = null,
+            bool ignoreRatelimit = false)
+        {
+            var request = await PrepareRequestAsync(apiClient, uri, method, cancellationToken, parameters, signed, parameterPosition, arraySerialization, requestWeight, deserializer, additionalHeaders, ignoreRatelimit).ConfigureAwait(false);
+            if (!request)
+                return new WebCallResult(request.Error!);
+
+            var result = await GetResponseAsync<object>(apiClient, request.Data, deserializer, cancellationToken, true).ConfigureAwait(false);
+            return result.AsDataless();
+        }
+
+        /// <summary>
+        /// Execute a request to the uri and deserialize the response into the provided type parameter
+        /// </summary>
+        /// <typeparam name="T">The type to deserialize into</typeparam>
+        /// <param name="apiClient">The API client the request is for</param>
+        /// <param name="uri">The uri to send the request to</param>
+        /// <param name="method">The method of the request</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <param name="parameters">The parameters of the request</param>
+        /// <param name="signed">Whether or not the request should be authenticated</param>
+        /// <param name="parameterPosition">Where the parameters should be placed, overwrites the value set in the client</param>
+        /// <param name="arraySerialization">How array parameters should be serialized, overwrites the value set in the client</param>
+        /// <param name="requestWeight">Credits used for the request</param>
+        /// <param name="deserializer">The JsonSerializer to use for deserialization</param>
+        /// <param name="additionalHeaders">Additional headers to send with the request</param>
+        /// <param name="ignoreRatelimit">Ignore rate limits for this request</param>
+        /// <returns></returns>
+        [return: NotNull]
+        protected virtual async Task<WebCallResult<T>> SendRequestAsync<T>(
+            RestApiClient apiClient,
+            Uri uri, 
+            HttpMethod method, 
+            CancellationToken cancellationToken,            
+            Dictionary<string, object>? parameters = null, 
+            bool signed = false, 
+            HttpMethodParameterPosition? parameterPosition = null,
+            ArrayParametersSerialization? arraySerialization = null, 
+            int requestWeight = 1,
+            JsonSerializer? deserializer = null,
+            Dictionary<string, string>? additionalHeaders = null,
+            bool ignoreRatelimit = false
+            ) where T : class
+        {
+            var request = await PrepareRequestAsync(apiClient, uri, method, cancellationToken, parameters, signed, parameterPosition, arraySerialization, requestWeight, deserializer, additionalHeaders, ignoreRatelimit).ConfigureAwait(false);
+            if (!request)
+                return new WebCallResult<T>(request.Error!);
+
+            return await GetResponseAsync<T>(apiClient, request.Data, deserializer, cancellationToken, false).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Prepares a request to be sent to the server
+        /// </summary>
+        /// <param name="apiClient">The API client the request is for</param>
+        /// <param name="uri">The uri to send the request to</param>
+        /// <param name="method">The method of the request</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <param name="parameters">The parameters of the request</param>
+        /// <param name="signed">Whether or not the request should be authenticated</param>
+        /// <param name="parameterPosition">Where the parameters should be placed, overwrites the value set in the client</param>
+        /// <param name="arraySerialization">How array parameters should be serialized, overwrites the value set in the client</param>
+        /// <param name="requestWeight">Credits used for the request</param>
+        /// <param name="deserializer">The JsonSerializer to use for deserialization</param>
+        /// <param name="additionalHeaders">Additional headers to send with the request</param>
+        /// <param name="ignoreRatelimit">Ignore rate limits for this request</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult<IRequest>> PrepareRequestAsync(RestApiClient apiClient,
+            Uri uri,
+            HttpMethod method,
+            CancellationToken cancellationToken,
+            Dictionary<string, object>? parameters = null,
+            bool signed = false,
+            HttpMethodParameterPosition? parameterPosition = null,
+            ArrayParametersSerialization? arraySerialization = null,
+            int requestWeight = 1,
+            JsonSerializer? deserializer = null,
+            Dictionary<string, string>? additionalHeaders = null,
+            bool ignoreRatelimit = false)
+        {
+            var requestId = NextId();
+
+            if (signed)
+            {
+                var syncTask = apiClient.SyncTimeAsync();
+                var timeSyncInfo = apiClient.GetTimeSyncInfo();
+                if (timeSyncInfo.TimeSyncState.LastSyncTime == default)
+                {
+                    // Initially with first request we'll need to wait for the time syncing, if it's not the first request we can just continue
+                    var syncTimeResult = await syncTask.ConfigureAwait(false);
+                    if (!syncTimeResult)
+                    {
+                        log.Write(LogLevel.Debug, $"[{requestId}] Failed to sync time, aborting request: " + syncTimeResult.Error);
+                        return syncTimeResult.As<IRequest>(default);
+                    }
+                }
+            }
+
+            if (!ignoreRatelimit)
+            {
+                foreach (var limiter in apiClient.RateLimiters)
+                {
+                    var limitResult = await limiter.LimitRequestAsync(log, uri.AbsolutePath, method, signed, apiClient.Options.ApiCredentials?.Key, apiClient.Options.RateLimitingBehaviour, requestWeight, cancellationToken).ConfigureAwait(false);
+                    if (!limitResult.Success)
+                        return new CallResult<IRequest>(limitResult.Error!);
+                }
+            }
+
+            if (signed && apiClient.AuthenticationProvider == null)
+            {
+                log.Write(LogLevel.Warning, $"[{requestId}] Request {uri.AbsolutePath} failed because no ApiCredentials were provided");
+                return new CallResult<IRequest>(new NoApiCredentialsError());
+            }
+
+            log.Write(LogLevel.Information, $"[{requestId}] Creating request for " + uri);
+            var paramsPosition = parameterPosition ?? apiClient.ParameterPositions[method];
+            var request = ConstructRequest(apiClient, uri, method, parameters, signed, paramsPosition, arraySerialization ?? apiClient.arraySerialization, requestId, additionalHeaders);
+
+            string? paramString = "";
+            if (paramsPosition == HttpMethodParameterPosition.InBody)
+                paramString = $" with request body '{request.Content}'";
+
+            var headers = request.GetHeaders();
+            if (headers.Any())
+                paramString += " with headers " + string.Join(", ", headers.Select(h => h.Key + $"=[{string.Join(",", h.Value)}]"));
+
+            apiClient.TotalRequestsMade++;
+            log.Write(LogLevel.Trace, $"[{requestId}] Sending {method}{(signed ? " signed" : "")} request to {request.Uri}{paramString ?? " "}{(ClientOptions.Proxy == null ? "" : $" via proxy {ClientOptions.Proxy.Host}")}");
+            return new CallResult<IRequest>(request);
+        }
+
+
+
+        /// <summary>
+        /// Executes the request and returns the result deserialized into the type parameter class
+        /// </summary>
+        /// <param name="apiClient">The client making the request</param>
+        /// <param name="request">The request object to execute</param>
+        /// <param name="deserializer">The JsonSerializer to use for deserialization</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <param name="expectedEmptyResponse">If an empty response is expected</param>
+        /// <returns></returns>
+        protected virtual async Task<WebCallResult<T>> GetResponseAsync<T>(
+            BaseApiClient apiClient, 
+            IRequest request, 
+            JsonSerializer? deserializer, 
+            CancellationToken cancellationToken,
+            bool expectedEmptyResponse)
+        {
+            try
+            {
+                var sw = Stopwatch.StartNew();
+                var response = await request.GetResponseAsync(cancellationToken).ConfigureAwait(false);
+                sw.Stop();
+                var statusCode = response.StatusCode;
+                var headers = response.ResponseHeaders;
+                var responseStream = await response.GetResponseStreamAsync().ConfigureAwait(false);
+                if (response.IsSuccessStatusCode)
+                {
+                    // If we have to manually parse error responses (can't rely on HttpStatusCode) we'll need to read the full
+                    // response before being able to deserialize it into the resulting type since we don't know if it an error response or data
+                    if (apiClient.manualParseError)
+                    {
+                        using var reader = new StreamReader(responseStream);
+                        var data = await reader.ReadToEndAsync().ConfigureAwait(false);
+                        responseStream.Close();
+                        response.Close();
+                        log.Write(LogLevel.Debug, $"[{request.RequestId}] Response received in {sw.ElapsedMilliseconds}ms{(log.Level == LogLevel.Trace ? (": "+data): "")}");
+
+                        if (!expectedEmptyResponse)
+                        {
+                            // Validate if it is valid json. Sometimes other data will be returned, 502 error html pages for example
+                            var parseResult = ValidateJson(data);
+                            if (!parseResult.Success)
+                                return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, ClientOptions.OutputOriginalData ? data : null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, parseResult.Error!);
+
+                            // Let the library implementation see if it is an error response, and if so parse the error
+                            var error = await TryParseErrorAsync(parseResult.Data).ConfigureAwait(false);
+                            if (error != null)
+                                return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, ClientOptions.OutputOriginalData ? data : null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, error!);
+
+                            // Not an error, so continue deserializing
+                            var deserializeResult = Deserialize<T>(parseResult.Data, deserializer, request.RequestId);
+                            return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, ClientOptions.OutputOriginalData ? data : null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), deserializeResult.Data, deserializeResult.Error);
+                        }
+                        else
+                        {
+                            if (!string.IsNullOrEmpty(data))
+                            {
+                                var parseResult = ValidateJson(data);
+                                if (!parseResult.Success)
+                                    // Not empty, and not json
+                                    return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, ClientOptions.OutputOriginalData ? data : null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, parseResult.Error!);
+
+                                var error = await TryParseErrorAsync(parseResult.Data).ConfigureAwait(false);
+                                if (error != null)
+                                    // Error response
+                                    return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, ClientOptions.OutputOriginalData ? data : null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, error!);
+                            }
+
+                            // Empty success response; okay
+                            return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, ClientOptions.OutputOriginalData ? data : null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, default);
+                        }
+                    }
+                    else
+                    {
+                        if (expectedEmptyResponse)
+                        {
+                            // We expected an empty response and the request is successful and don't manually parse errors, so assume it's correct
+                            responseStream.Close();
+                            response.Close();
+
+                            return new WebCallResult<T>(statusCode, headers, sw.Elapsed, null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, null);
+                        }
+
+                        // Success status code, and we don't have to check for errors. Continue deserializing directly from the stream
+                        var desResult = await DeserializeAsync<T>(responseStream, deserializer, request.RequestId, sw.ElapsedMilliseconds).ConfigureAwait(false);
+                        responseStream.Close();
+                        response.Close();
+
+                        return new WebCallResult<T>(statusCode, headers, sw.Elapsed, ClientOptions.OutputOriginalData ? desResult.OriginalData : null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), desResult.Data, desResult.Error);
+                    }
+                }
+                else
+                {
+                    // Http status code indicates error
+                    using var reader = new StreamReader(responseStream);
+                    var data = await reader.ReadToEndAsync().ConfigureAwait(false);
+                    log.Write(LogLevel.Warning, $"[{request.RequestId}] Error received in {sw.ElapsedMilliseconds}ms: {data}");
+                    responseStream.Close();
+                    response.Close();
+                    var parseResult = ValidateJson(data);
+                    var error = parseResult.Success ? ParseErrorResponse(parseResult.Data) : parseResult.Error!;
+                    if(error.Code == null || error.Code == 0)
+                        error.Code = (int)response.StatusCode;
+                    return new WebCallResult<T>(statusCode, headers, sw.Elapsed, data, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, error);
+                }
+            }
+            catch (HttpRequestException requestException)
+            {
+                // Request exception, can't reach server for instance
+                var exceptionInfo = requestException.ToLogString();
+                log.Write(LogLevel.Warning, $"[{request.RequestId}] Request exception: " + exceptionInfo);
+                return new WebCallResult<T>(null, null, null, null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, new WebError(exceptionInfo));
+            }
+            catch (OperationCanceledException canceledException)
+            {
+                if (cancellationToken != default && canceledException.CancellationToken == cancellationToken)
+                {
+                    // Cancellation token canceled by caller
+                    log.Write(LogLevel.Warning, $"[{request.RequestId}] Request canceled by cancellation token");
+                    return new WebCallResult<T>(null, null, null, null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, new CancellationRequestedError());
+                }
+                else
+                {
+                    // Request timed out
+                    log.Write(LogLevel.Warning, $"[{request.RequestId}] Request timed out: " + canceledException.ToLogString());
+                    return new WebCallResult<T>(null, null, null, null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, new WebError($"[{request.RequestId}] Request timed out"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Can be used to parse an error even though response status indicates success. Some apis always return 200 OK, even though there is an error.
+        /// When setting manualParseError to true this method will be called for each response to be able to check if the response is an error or not.
+        /// If the response is an error this method should return the parsed error, else it should return null
+        /// </summary>
+        /// <param name="data">Received data</param>
+        /// <returns>Null if not an error, Error otherwise</returns>
+        protected virtual Task<ServerError?> TryParseErrorAsync(JToken data)
+        {
+            return Task.FromResult<ServerError?>(null);
+        }
+
+        /// <summary>
+        /// Creates a request object
+        /// </summary>
+        /// <param name="apiClient">The API client the request is for</param>
+        /// <param name="uri">The uri to send the request to</param>
+        /// <param name="method">The method of the request</param>
+        /// <param name="parameters">The parameters of the request</param>
+        /// <param name="signed">Whether or not the request should be authenticated</param>
+        /// <param name="parameterPosition">Where the parameters should be placed</param>
+        /// <param name="arraySerialization">How array parameters should be serialized</param>
+        /// <param name="requestId">Unique id of a request</param>
+        /// <param name="additionalHeaders">Additional headers to send with the request</param>
+        /// <returns></returns>
+        protected virtual IRequest ConstructRequest(
+            RestApiClient apiClient,
+            Uri uri,
+            HttpMethod method,
+            Dictionary<string, object>? parameters,
+            bool signed,
+            HttpMethodParameterPosition parameterPosition,
+            ArrayParametersSerialization arraySerialization,
+            int requestId,
+            Dictionary<string, string>? additionalHeaders)
+        {
+            parameters ??= new Dictionary<string, object>();
+
+            for (var i = 0; i< parameters.Count; i++)
+            {
+                var kvp = parameters.ElementAt(i);
+                if (kvp.Value is Func<object> delegateValue)
+                    parameters[kvp.Key] = delegateValue();
+            }
+
+            if (parameterPosition == HttpMethodParameterPosition.InUri)
+            {
+                foreach (var parameter in parameters)
+                    uri = uri.AddQueryParmeter(parameter.Key, parameter.Value.ToString());
+            }
+
+            var headers = new Dictionary<string, string>();
+            var uriParameters = parameterPosition == HttpMethodParameterPosition.InUri ? new SortedDictionary<string, object>(parameters) : new SortedDictionary<string, object>();
+            var bodyParameters = parameterPosition == HttpMethodParameterPosition.InBody ? new SortedDictionary<string, object>(parameters) : new SortedDictionary<string, object>();
+            if (apiClient.AuthenticationProvider != null)
+                apiClient.AuthenticationProvider.AuthenticateRequest(
+                    apiClient, 
+                    uri, 
+                    method, 
+                    parameters, 
+                    signed, 
+                    arraySerialization,
+                    parameterPosition,
+                    out uriParameters, 
+                    out bodyParameters, 
+                    out headers);
+                 
+            // Sanity check
+            foreach(var param in parameters)
+            {
+                if (!uriParameters.ContainsKey(param.Key) && !bodyParameters.ContainsKey(param.Key))
+                    throw new Exception($"Missing parameter {param.Key} after authentication processing. AuthenticationProvider implementation " +
+                        $"should return provided parameters in either the uri or body parameters output");
+            }
+
+            // Add the auth parameters to the uri, start with a new URI to be able to sort the parameters including the auth parameters            
+            uri = uri.SetParameters(uriParameters, arraySerialization);
+        
+            var request = RequestFactory.Create(method, uri, requestId);
+            request.Accept = Constants.JsonContentHeader;
+
+            foreach (var header in headers)
+                request.AddHeader(header.Key, header.Value);
+
+            if (additionalHeaders != null)
+            {
+                foreach (var header in additionalHeaders)
+                    request.AddHeader(header.Key, header.Value);
+            }
+
+            if (StandardRequestHeaders != null)
+            {
+                foreach (var header in StandardRequestHeaders)
+                    // Only add it if it isn't overwritten
+                    if (additionalHeaders?.ContainsKey(header.Key) != true)
+                        request.AddHeader(header.Key, header.Value);
+            }
+
+            if (parameterPosition == HttpMethodParameterPosition.InBody)
+            {
+                var contentType = apiClient.requestBodyFormat == RequestBodyFormat.Json ? Constants.JsonContentHeader : Constants.FormContentHeader;
+                if (bodyParameters.Any())
+                    WriteParamBody(apiClient, request, bodyParameters, contentType);
+                else
+                    request.SetContent(apiClient.requestBodyEmptyContent, contentType);
+            }
+
+            return request;
+        }
+
+        /// <summary>
+        /// Writes the parameters of the request to the request object body
+        /// </summary>
+        /// <param name="apiClient">The client making the request</param>
+        /// <param name="request">The request to set the parameters on</param>
+        /// <param name="parameters">The parameters to set</param>
+        /// <param name="contentType">The content type of the data</param>
+        protected virtual void WriteParamBody(BaseApiClient apiClient, IRequest request, SortedDictionary<string, object> parameters, string contentType)
+        {
+            if (apiClient.requestBodyFormat == RequestBodyFormat.Json)
+            {
+                // Write the parameters as json in the body
+                var stringData = JsonConvert.SerializeObject(parameters);
+                request.SetContent(stringData, contentType);
+            }
+            else if (apiClient.requestBodyFormat == RequestBodyFormat.FormData)
+            {
+                // Write the parameters as form data in the body
+                var stringData = parameters.ToFormData();
+                request.SetContent(stringData, contentType);
+            }
+        }
+
+        /// <summary>
+        /// Parse an error response from the server. Only used when server returns a status other than Success(200)
+        /// </summary>
+        /// <param name="error">The string the request returned</param>
+        /// <returns></returns>
+        protected virtual Error ParseErrorResponse(JToken error)
+        {
+            return new ServerError(error.ToString());
         }
     }
 }

CryptoExchange.Net/Clients/BaseSocketClient.cs

@@ -1,11 +1,17 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
+using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Sockets;
 using Microsoft.Extensions.Logging;
+using Newtonsoft.Json.Linq;
 
 namespace CryptoExchange.Net
 {
@@ -15,27 +21,670 @@ namespace CryptoExchange.Net
     public abstract class BaseSocketClient: BaseClient, ISocketClient
     {
         #region fields
-        
+        /// <summary>
+        /// The factory for creating sockets. Used for unit testing
+        /// </summary>
+        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>
+        /// Delegate used for processing byte data received from socket connections before it is processed by handlers
+        /// </summary>
+        protected Func<byte[], string>? dataInterpreterBytes;
+        /// <summary>
+        /// Delegate used for processing string data received from socket connections before it is processed by handlers
+        /// </summary>
+        protected Func<string, string>? dataInterpreterString;
+        /// <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 Dictionary<string, Action<MessageEvent>> genericHandlers = new();
+        /// <summary>
+        /// The task that is sending periodic data on the websocket. Can be used for sending Ping messages every x seconds or similair. Not necesarry.
+        /// </summary>
+        protected Task? periodicTask;
+        /// <summary>
+        /// Wait event for the periodicTask
+        /// </summary>
+        protected AsyncResetEvent? periodicEvent;
         /// <summary>
         /// If client is disposing
         /// </summary>
-        protected bool _disposing;
-        
+        protected bool disposing;
+
+        /// <summary>
+        /// If true; data which is a response to a query will also be distributed to subscriptions
+        /// If false; data which is a response to a query won't get forwarded to subscriptions as well
+        /// </summary>
+        protected internal bool ContinueOnQueryResponse { get; protected set; }
+
+        /// <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 max amount of outgoing messages per socket per second
+        /// </summary>
+        protected internal int? RateLimitPerSocketPerSecond { get; set; }
+
         /// <inheritdoc />
-        public int CurrentConnections => ApiClients.OfType<SocketApiClient>().Sum(c => c.CurrentConnections);
+        public double IncomingKbps
+        {
+            get
+            {
+                if (!socketConnections.Any())
+                    return 0;
+
+                return socketConnections.Sum(s => s.Value.IncomingKbps);
+            }
+        }
+
         /// <inheritdoc />
-        public int CurrentSubscriptions => ApiClients.OfType<SocketApiClient>().Sum(s => s.CurrentSubscriptions);
+        public int CurrentConnections => socketConnections.Count;
         /// <inheritdoc />
-        public double IncomingKbps => ApiClients.OfType<SocketApiClient>().Sum(s => s.IncomingKbps);
+        public int CurrentSubscriptions
+        {
+            get
+            {
+                if (!socketConnections.Any())
+                    return 0;
+
+                return socketConnections.Sum(s => s.Value.SubscriptionCount);
+            }
+        }
+
+        /// <summary>
+        /// Client options
+        /// </summary>
+        public new BaseSocketClientOptions ClientOptions { get; }
+
         #endregion
 
         /// <summary>
         /// ctor
         /// </summary>
-        /// <param name="logger">Logger</param>
         /// <param name="name">The name of the API this client is for</param>
-        protected BaseSocketClient(ILoggerFactory? logger, string name) : base(logger, name)
+        /// <param name="options">The options for this client</param>
+        protected BaseSocketClient(string name, BaseSocketClientOptions options) : base(name, options)
         {
+            ClientOptions = options ?? throw new ArgumentNullException(nameof(options));
+        }
+
+        /// <inheritdoc />
+        public void SetApiCredentials(ApiCredentials credentials)
+        {
+            foreach (var apiClient in ApiClients)
+                apiClient.SetApiCredentials(credentials);
+        }
+
+        /// <summary>
+        /// Set a delegate to be used for processing data received from socket connections before it is processed by handlers
+        /// </summary>
+        /// <param name="byteHandler">Handler for byte data</param>
+        /// <param name="stringHandler">Handler for string data</param>
+        protected void SetDataInterpreter(Func<byte[], string>? byteHandler, Func<string, string>? stringHandler)
+        {
+            dataInterpreterBytes = byteHandler;
+            dataInterpreterString = stringHandler;
+        }
+
+        /// <summary>
+        /// Connect to an url and listen for data on the BaseAddress
+        /// </summary>
+        /// <typeparam name="T">The type of the expected data</typeparam>
+        /// <param name="apiClient">The API client the subscription is for</param>
+        /// <param name="request">The optional request object to send, will be serialized to json</param>
+        /// <param name="identifier">The identifier to use, necessary if no request object is sent</param>
+        /// <param name="authenticated">If the subscription is to an authenticated endpoint</param>
+        /// <param name="dataHandler">The handler of update data</param>
+        /// <param name="ct">Cancellation token for closing this subscription</param>
+        /// <returns></returns>
+        protected virtual Task<CallResult<UpdateSubscription>> SubscribeAsync<T>(SocketApiClient apiClient, object? request, string? identifier, bool authenticated, Action<DataEvent<T>> dataHandler, CancellationToken ct)
+        {
+            return SubscribeAsync(apiClient, apiClient.Options.BaseAddress, request, identifier, authenticated, dataHandler, ct);
+        }
+
+        /// <summary>
+        /// Connect to an url and listen for data
+        /// </summary>
+        /// <typeparam name="T">The type of the expected data</typeparam>
+        /// <param name="apiClient">The API client the subscription is for</param>
+        /// <param name="url">The URL to connect to</param>
+        /// <param name="request">The optional request object to send, will be serialized to json</param>
+        /// <param name="identifier">The identifier to use, necessary if no request object is sent</param>
+        /// <param name="authenticated">If the subscription is to an authenticated endpoint</param>
+        /// <param name="dataHandler">The handler of update data</param>
+        /// <param name="ct">Cancellation token for closing this subscription</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult<UpdateSubscription>> SubscribeAsync<T>(SocketApiClient apiClient, string url, object? request, string? identifier, bool authenticated, Action<DataEvent<T>> dataHandler, CancellationToken ct)
+        {
+            if (disposing)
+                return new CallResult<UpdateSubscription>(new InvalidOperationError("Client disposed, can't subscribe"));
+
+            SocketConnection socketConnection;
+            SocketSubscription? subscription;
+            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(apiClient, url, authenticated).ConfigureAwait(false);
+                    if(!socketResult)
+                        return socketResult.As<UpdateSubscription>(null);                    
+
+                    socketConnection = socketResult.Data;
+
+                    // Add a subscription on the socket connection
+                    subscription = AddSubscription(request, identifier, true, socketConnection, dataHandler, authenticated);
+                    if (subscription == null)
+                    {
+                        log.Write(LogLevel.Trace, $"Socket {socketConnection.SocketId} failed to add subscription, retrying on different connection");
+                        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, authenticated).ConfigureAwait(false);
+                    if (!connectResult)
+                        return new CallResult<UpdateSubscription>(connectResult.Error!);
+
+                    break;
+                }
+            }
+            finally
+            {
+                if(!released)
+                    semaphoreSlim.Release();
+            }
+
+            if (socketConnection.PausedActivity)
+            {
+                log.Write(LogLevel.Warning, $"Socket {socketConnection.SocketId} has been paused, can't subscribe at this moment");
+                return new CallResult<UpdateSubscription>( new ServerError("Socket is paused"));
+            }
+
+            if (request != null)
+            {
+                // Send the request and wait for answer
+                var subResult = await SubscribeAndWaitAsync(socketConnection, request, subscription).ConfigureAwait(false);
+                if (!subResult)
+                {
+                    log.Write(LogLevel.Warning, $"Socket {socketConnection.SocketId} failed to subscribe: {subResult.Error}");
+                    await socketConnection.CloseAsync(subscription).ConfigureAwait(false);
+                    return new CallResult<UpdateSubscription>(subResult.Error!);
+                }
+            }
+            else
+            {
+                // No request to be sent, so just mark the subscription as comfirmed
+                subscription.Confirmed = true;
+            }
+
+            if (ct != default)
+            {
+                subscription.CancellationTokenRegistration = ct.Register(async () =>
+                {
+                    log.Write(LogLevel.Information, $"Socket {socketConnection.SocketId} Cancellation token set, closing subscription");
+                    await socketConnection.CloseAsync(subscription).ConfigureAwait(false);
+                }, false);
+            }
+
+            log.Write(LogLevel.Information, $"Socket {socketConnection.SocketId} subscription {subscription.Id} completed successfully");
+            return new CallResult<UpdateSubscription>(new UpdateSubscription(socketConnection, subscription));
+        }
+
+        /// <summary>
+        /// Sends the subscribe request and waits for a response to that request
+        /// </summary>
+        /// <param name="socketConnection">The connection to send the request on</param>
+        /// <param name="request">The request to send, will be serialized to json</param>
+        /// <param name="subscription">The subscription the request is for</param>
+        /// <returns></returns>
+        protected internal virtual async Task<CallResult<bool>> SubscribeAndWaitAsync(SocketConnection socketConnection, object request, SocketSubscription subscription)
+        {
+            CallResult<object>? callResult = null;
+            await socketConnection.SendAndWaitAsync(request, ClientOptions.SocketResponseTimeout, data => HandleSubscriptionResponse(socketConnection, subscription, request, data, out callResult)).ConfigureAwait(false);
+
+            if (callResult?.Success == true)
+            {
+                subscription.Confirmed = true;
+                return new CallResult<bool>(true);
+            }
+
+            if(callResult== null)
+                return new CallResult<bool>(new ServerError("No response on subscription request received"));
+
+            return new CallResult<bool>(callResult.Error!);
+        }
+
+        /// <summary>
+        /// Send a query on a socket connection to the BaseAddress and wait for the response
+        /// </summary>
+        /// <typeparam name="T">Expected result type</typeparam>
+        /// <param name="apiClient">The API client the query is for</param>
+        /// <param name="request">The request to send, will be serialized to json</param>
+        /// <param name="authenticated">If the query is to an authenticated endpoint</param>
+        /// <returns></returns>
+        protected virtual Task<CallResult<T>> QueryAsync<T>(SocketApiClient apiClient, object request, bool authenticated)
+        {
+            return QueryAsync<T>(apiClient, apiClient.Options.BaseAddress, request, authenticated);
+        }
+
+        /// <summary>
+        /// Send a query on a socket connection and wait for the response
+        /// </summary>
+        /// <typeparam name="T">The expected result type</typeparam>
+        /// <param name="apiClient">The API client the query is for</param>
+        /// <param name="url">The url for the request</param>
+        /// <param name="request">The request to send</param>
+        /// <param name="authenticated">Whether the socket should be authenticated</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult<T>> QueryAsync<T>(SocketApiClient apiClient, string url, object request, bool authenticated)
+        {
+            if (disposing)
+                return new CallResult<T>(new InvalidOperationError("Client disposed, can't query"));
+
+            SocketConnection socketConnection;
+            var released = false;
+            await semaphoreSlim.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                var socketResult = await GetSocketConnection(apiClient, url, authenticated).ConfigureAwait(false);
+                if (!socketResult)
+                    return socketResult.As<T>(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, authenticated).ConfigureAwait(false);
+                if (!connectResult)
+                    return new CallResult<T>(connectResult.Error!);
+            }
+            finally
+            {
+                if (!released)
+                    semaphoreSlim.Release();
+            }
+
+            if (socketConnection.PausedActivity)
+            {
+                log.Write(LogLevel.Warning, $"Socket {socketConnection.SocketId} has been paused, can't send query at this moment");
+                return new CallResult<T>(new ServerError("Socket is paused"));
+            }
+
+            return await QueryAndWaitAsync<T>(socketConnection, request).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Sends the query request and waits for the result
+        /// </summary>
+        /// <typeparam name="T">The expected result type</typeparam>
+        /// <param name="socket">The connection to send and wait on</param>
+        /// <param name="request">The request to send</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult<T>> QueryAndWaitAsync<T>(SocketConnection socket, object request)
+        {
+            var dataResult = new CallResult<T>(new ServerError("No response on query received"));
+            await socket.SendAndWaitAsync(request, ClientOptions.SocketResponseTimeout, data =>
+            {
+                if (!HandleQueryResponse<T>(socket, request, data, out var callResult))
+                    return false;
+
+                dataResult = callResult;
+                return true;
+            }).ConfigureAwait(false);
+
+            return dataResult;
+        }
+
+        /// <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<bool>> ConnectIfNeededAsync(SocketConnection socket, bool authenticated)
+        {
+            if (socket.Connected)
+                return new CallResult<bool>(true);
+
+            var connectResult = await ConnectSocketAsync(socket).ConfigureAwait(false);
+            if (!connectResult)
+                return new CallResult<bool>(connectResult.Error!);
+
+            if (!authenticated || socket.Authenticated)
+                return new CallResult<bool>(true);
+
+            var result = await AuthenticateSocketAsync(socket).ConfigureAwait(false);
+            if (!result)
+            {
+                await socket.CloseAsync().ConfigureAwait(false);
+                log.Write(LogLevel.Warning, $"Socket {socket.SocketId} authentication failed");
+                result.Error!.Message = "Authentication failed: " + result.Error.Message;
+                return new CallResult<bool>(result.Error);
+            }
+
+            socket.Authenticated = true;
+            return new CallResult<bool>(true);
+        }
+
+        /// <summary>
+        /// The socketConnection received data (the data JToken parameter). The implementation of this method should check if the received data is a response to the query that was send (the request parameter).
+        /// For example; A query is sent in a request message with an Id parameter with value 10. The socket receives data and calls this method to see if the data it received is an
+        /// anwser to any query that was done. The implementation of this method should check if the response.Id == request.Id to see if they match (assuming the api has some sort of Id tracking on messages,
+        /// if not some other method has be implemented to match the messages).
+        /// If the messages match, the callResult out parameter should be set with the deserialized data in the from of (T) and return true.
+        /// </summary>
+        /// <typeparam name="T">The type of response that is expected on the query</typeparam>
+        /// <param name="socketConnection">The socket connection</param>
+        /// <param name="request">The request that a response is awaited for</param>
+        /// <param name="data">The message received from the server</param>
+        /// <param name="callResult">The interpretation (null if message wasn't a response to the request)</param>
+        /// <returns>True if the message was a response to the query</returns>
+        protected internal abstract bool HandleQueryResponse<T>(SocketConnection socketConnection, object request, JToken data, [NotNullWhen(true)]out CallResult<T>? callResult);
+        /// <summary>
+        /// The socketConnection received data (the data JToken parameter). The implementation of this method should check if the received data is a response to the subscription request that was send (the request parameter).
+        /// For example; A subscribe request message is send with an Id parameter with value 10. The socket receives data and calls this method to see if the data it received is an
+        /// anwser to any subscription request that was done. The implementation of this method should check if the response.Id == request.Id to see if they match (assuming the api has some sort of Id tracking on messages,
+        /// if not some other method has be implemented to match the messages).
+        /// If the messages match, the callResult out parameter should be set with the deserialized data in the from of (T) and return true.
+        /// </summary>
+        /// <param name="socketConnection">The socket connection</param>
+        /// <param name="subscription">A subscription that waiting for a subscription response</param>
+        /// <param name="request">The request that the subscription sent</param>
+        /// <param name="data">The message received from the server</param>
+        /// <param name="callResult">The interpretation (null if message wasn't a response to the request)</param>
+        /// <returns>True if the message was a response to the subscription request</returns>
+        protected internal abstract bool HandleSubscriptionResponse(SocketConnection socketConnection, SocketSubscription subscription, object request, JToken data, out CallResult<object>? callResult);
+        /// <summary>
+        /// Needs to check if a received message matches a handler by request. After subscribing data message will come in. These data messages need to be matched to a specific connection
+        /// to pass the correct data to the correct handler. The implementation of this method should check if the message received matches the subscribe request that was sent.
+        /// </summary>
+        /// <param name="socketConnection">The socket connection the message was recieved on</param>
+        /// <param name="message">The received data</param>
+        /// <param name="request">The subscription request</param>
+        /// <returns>True if the message is for the subscription which sent the request</returns>
+        protected internal abstract bool MessageMatchesHandler(SocketConnection socketConnection, JToken message, object request);
+        /// <summary>
+        /// Needs to check if a received message matches a handler by identifier. Generally used by GenericHandlers. For example; a generic handler is registered which handles ping messages
+        /// from the server. This method should check if the message received is a ping message and the identifer is the identifier of the GenericHandler
+        /// </summary>
+        /// <param name="socketConnection">The socket connection the message was recieved on</param>
+        /// <param name="message">The received data</param>
+        /// <param name="identifier">The string identifier of the handler</param>
+        /// <returns>True if the message is for the handler which has the identifier</returns>
+        protected internal abstract bool MessageMatchesHandler(SocketConnection socketConnection, JToken message, string identifier);
+        /// <summary>
+        /// Needs to authenticate the socket so authenticated queries/subscriptions can be made on this socket connection
+        /// </summary>
+        /// <param name="socketConnection">The socket connection that should be authenticated</param>
+        /// <returns></returns>
+        protected internal abstract Task<CallResult<bool>> AuthenticateSocketAsync(SocketConnection socketConnection);
+        /// <summary>
+        /// Needs to unsubscribe a subscription, typically by sending an unsubscribe request. If multiple subscriptions per socket is not allowed this can just return since the socket will be closed anyway
+        /// </summary>
+        /// <param name="connection">The connection on which to unsubscribe</param>
+        /// <param name="subscriptionToUnsub">The subscription to unsubscribe</param>
+        /// <returns></returns>
+        protected internal abstract Task<bool> UnsubscribeAsync(SocketConnection connection, SocketSubscription subscriptionToUnsub);
+
+        /// <summary>
+        /// Optional handler to interpolate data before sending it to the handlers
+        /// </summary>
+        /// <param name="message"></param>
+        /// <returns></returns>
+        protected internal virtual JToken ProcessTokenData(JToken message)
+        {
+            return message;
+        }
+
+        /// <summary>
+        /// Add a subscription to a connection
+        /// </summary>
+        /// <typeparam name="T">The type of data the subscription expects</typeparam>
+        /// <param name="request">The request of the subscription</param>
+        /// <param name="identifier">The identifier of the subscription (can be null if request param is used)</param>
+        /// <param name="userSubscription">Whether or not this is a user subscription (counts towards the max amount of handlers on a socket)</param>
+        /// <param name="connection">The socket connection the handler is on</param>
+        /// <param name="dataHandler">The handler of the data received</param>
+        /// <param name="authenticated">Whether the subscription needs authentication</param>
+        /// <returns></returns>
+        protected virtual SocketSubscription? AddSubscription<T>(object? request, string? identifier, bool userSubscription, SocketConnection connection, Action<DataEvent<T>> dataHandler, bool authenticated)
+        {
+            void InternalHandler(MessageEvent messageEvent)
+            {
+                if (typeof(T) == typeof(string))
+                {
+                    var stringData = (T)Convert.ChangeType(messageEvent.JsonData.ToString(), typeof(T));
+                    dataHandler(new DataEvent<T>(stringData, null, ClientOptions.OutputOriginalData ? messageEvent.OriginalData : null, messageEvent.ReceivedTimestamp));
+                    return;
+                }
+
+                var desResult = Deserialize<T>(messageEvent.JsonData);
+                if (!desResult)
+                {
+                    log.Write(LogLevel.Warning, $"Socket {connection.SocketId} Failed to deserialize data into type {typeof(T)}: {desResult.Error}");
+                    return;
+                }
+
+                dataHandler(new DataEvent<T>(desResult.Data, null, ClientOptions.OutputOriginalData ? messageEvent.OriginalData : null, messageEvent.ReceivedTimestamp));
+            }
+
+            var subscription = request == null
+                ? SocketSubscription.CreateForIdentifier(NextId(), identifier!, userSubscription, authenticated, InternalHandler)
+                : SocketSubscription.CreateForRequest(NextId(), request, userSubscription, authenticated, InternalHandler);
+            if (!connection.AddSubscription(subscription))
+                return null;
+            return subscription;
+        }
+
+        /// <summary>
+        /// Adds a generic message handler. Used for example to reply to ping requests
+        /// </summary>
+        /// <param name="identifier">The name of the request handler. Needs to be unique</param>
+        /// <param name="action">The action to execute when receiving a message for this handler (checked by <see cref="MessageMatchesHandler(SocketConnection, Newtonsoft.Json.Linq.JToken,string)"/>)</param>
+        protected void AddGenericHandler(string identifier, Action<MessageEvent> action)
+        {
+            genericHandlers.Add(identifier, action);
+            var subscription = SocketSubscription.CreateForIdentifier(NextId(), identifier, false, false, action);
+            foreach (var connection in socketConnections.Values)
+                connection.AddSubscription(subscription);
+        }
+
+        /// <summary>
+        /// Get the url to connect to (defaults to BaseAddress form the client options)
+        /// </summary>
+        /// <param name="apiClient"></param>
+        /// <param name="address"></param>
+        /// <param name="authentication"></param>
+        /// <returns></returns>
+        protected virtual Task<CallResult<string?>> GetConnectionUrlAsync(SocketApiClient apiClient, string address, bool authentication)
+        {
+            return Task.FromResult(new CallResult<string?>(address));
+        }
+
+        /// <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="apiClient">The API client the connection is for</param>
+        /// <param name="address">The address the socket is for</param>
+        /// <param name="authenticated">Whether the socket should be authenticated</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult<SocketConnection>> GetSocketConnection(SocketApiClient apiClient, string address, bool authenticated)
+        {
+            var socketResult = 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() == apiClient.GetType())
+                                                  && (s.Value.Authenticated == authenticated || !authenticated) && s.Value.Connected).OrderBy(s => s.Value.SubscriptionCount).FirstOrDefault();
+            var result = socketResult.Equals(default(KeyValuePair<int, SocketConnection>)) ? null : socketResult.Value;
+            if (result != null)
+            {
+                if (result.SubscriptionCount < ClientOptions.SocketSubscriptionsCombineTarget || (socketConnections.Count >= ClientOptions.MaxSocketConnections && socketConnections.All(s => s.Value.SubscriptionCount >= 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>(result);
+                }
+            }
+
+            var connectionAddress = await GetConnectionUrlAsync(apiClient, address, authenticated).ConfigureAwait(false);
+            if (!connectionAddress)
+            {
+                log.Write(LogLevel.Warning, $"Failed to determine connection url: " + connectionAddress.Error);
+                return connectionAddress.As<SocketConnection>(null);
+            }
+
+            if (connectionAddress.Data != address)
+                log.Write(LogLevel.Debug, $"Connection address set to " + connectionAddress.Data);
+
+            // Create new socket
+            var socket = CreateSocket(connectionAddress.Data!);
+            var socketConnection = new SocketConnection(this, apiClient, socket, address);
+            socketConnection.UnhandledMessage += HandleUnhandledMessage;
+            foreach (var kvp in genericHandlers)
+            {
+                var handler = SocketSubscription.CreateForIdentifier(NextId(), kvp.Key, false, false, kvp.Value);
+                socketConnection.AddSubscription(handler);
+            }
+
+            return new CallResult<SocketConnection>(socketConnection);
+        }
+
+        /// <summary>
+        /// Process an unhandled message
+        /// </summary>
+        /// <param name="token">The token that wasn't processed</param>
+        protected virtual void HandleUnhandledMessage(JToken token)
+        {
+        }
+
+        /// <summary>
+        /// Connect a socket
+        /// </summary>
+        /// <param name="socketConnection">The socket to connect</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult<bool>> ConnectSocketAsync(SocketConnection socketConnection)
+        {
+            if (await socketConnection.ConnectAsync().ConfigureAwait(false))
+            {
+                socketConnections.TryAdd(socketConnection.SocketId, socketConnection);
+                return new CallResult<bool>(true);
+            }
+
+            socketConnection.Dispose();
+            return new CallResult<bool>(new CantConnectError());
+        }
+
+        /// <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.AutoReconnect)
+               {
+                   DataInterpreterBytes = dataInterpreterBytes,
+                   DataInterpreterString = dataInterpreterString,
+                   KeepAliveInterval = KeepAliveInterval,
+                   ReconnectInterval = ClientOptions.ReconnectInterval,
+                   RatelimitPerSecond = RateLimitPerSocketPerSecond,
+                   Proxy = ClientOptions.Proxy,
+                   Timeout = 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(log, GetWebSocketParameters(address));
+            log.Write(LogLevel.Debug, $"Socket {socket.Id} new socket created for " + address);
+            return socket;
+        }
+
+        /// <summary>
+        /// Periodically sends data over a socket connection
+        /// </summary>
+        /// <param name="identifier">Identifier for the periodic send</param>
+        /// <param name="interval">How often</param>
+        /// <param name="objGetter">Method returning the object to send</param>
+        public virtual void SendPeriodic(string identifier, TimeSpan interval, Func<SocketConnection, object> objGetter)
+        {
+            if (objGetter == null)
+                throw new ArgumentNullException(nameof(objGetter));
+
+            periodicEvent = new AsyncResetEvent();
+            periodicTask = Task.Run(async () =>
+            {
+                while (!disposing)
+                {
+                    await periodicEvent.WaitAsync(interval).ConfigureAwait(false);
+                    if (disposing)
+                        break;
+                    
+                    foreach (var socketConnection in socketConnections.Values)
+                    {
+                        if (disposing)
+                            break;
+
+                        if (!socketConnection.Connected)
+                            continue;
+
+                        var obj = objGetter(socketConnection);
+                        if (obj == null)
+                            continue;
+
+                        log.Write(LogLevel.Trace, $"Socket {socketConnection.SocketId} sending periodic {identifier}");
+
+                        try
+                        {
+                            socketConnection.Send(obj);
+                        }
+                        catch (Exception ex)
+                        {
+                            log.Write(LogLevel.Warning, $"Socket {socketConnection.SocketId} Periodic send {identifier} failed: " + ex.ToLogString());
+                        }
+                    }
+                }
+            });
         }
 
         /// <summary>
@@ -45,12 +694,23 @@ namespace CryptoExchange.Net
         /// <returns></returns>
         public virtual async Task UnsubscribeAsync(int subscriptionId)
         {
-            foreach(var socket in ApiClients.OfType<SocketApiClient>())
+            SocketSubscription? subscription = null;
+            SocketConnection? connection = null;
+            foreach(var socket in socketConnections.Values.ToList())
             {
-                var result = await socket.UnsubscribeAsync(subscriptionId).ConfigureAwait(false);
-                if (result)
-                    break;                
+                subscription = socket.GetSubscription(subscriptionId);
+                if (subscription != null)
+                {
+                    connection = socket;
+                    break;
+                }
             }
+
+            if (subscription == null || connection == null)
+                return;
+
+            log.Write(LogLevel.Information, $"Socket {connection.SocketId} Unsubscribing subscription " + subscriptionId);
+            await connection.CloseAsync(subscription).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -63,7 +723,7 @@ namespace CryptoExchange.Net
             if (subscription == null)
                 throw new ArgumentNullException(nameof(subscription));
 
-            _logger.Log(LogLevel.Information, $"Socket {subscription.SocketId} Unsubscribing subscription  " + subscription.Id);
+            log.Write(LogLevel.Information, $"Socket {subscription.SocketId} Unsubscribing subscription  " + subscription.Id);
             await subscription.CloseAsync().ConfigureAwait(false);
         }
 
@@ -73,10 +733,14 @@ namespace CryptoExchange.Net
         /// <returns></returns>
         public virtual async Task UnsubscribeAllAsync()
         {
-            var tasks = new List<Task>();            
-            foreach (var client in ApiClients.OfType<SocketApiClient>())
-                tasks.Add(client.UnsubscribeAllAsync());
-            
+            log.Write(LogLevel.Information, $"Unsubscribing all {socketConnections.Sum(s => s.Value.SubscriptionCount)} subscriptions");
+            var tasks = new List<Task>();
+            {
+                var socketList = socketConnections.Values;
+                foreach (var sub in socketList)
+                    tasks.Add(sub.CloseAsync());
+            }
+
             await Task.WhenAll(tasks.ToArray()).ConfigureAwait(false);
         }
 
@@ -86,12 +750,14 @@ namespace CryptoExchange.Net
         /// <returns></returns>
         public virtual async Task ReconnectAsync()
         {
-            _logger.Log(LogLevel.Information, $"Reconnecting all {CurrentConnections} connections");
+            log.Write(LogLevel.Information, $"Reconnecting all {socketConnections.Count} connections");
             var tasks = new List<Task>();
-            foreach (var client in ApiClients.OfType<SocketApiClient>())
             {
-                tasks.Add(client.ReconnectAsync());
+                var socketList = socketConnections.Values;
+                foreach (var sub in socketList)
+                    tasks.Add(sub.TriggerReconnectAsync());
             }
+
             await Task.WhenAll(tasks.ToArray()).ConfigureAwait(false);
         }
 
@@ -100,10 +766,32 @@ namespace CryptoExchange.Net
         /// </summary>
         public string GetSubscriptionsState()
         {
-            var result = new StringBuilder();
-            foreach(var client in ApiClients.OfType<SocketApiClient>())            
-                result.AppendLine(client.GetSubscriptionsState());            
-            return result.ToString();
+            var sb = new StringBuilder();
+            sb.AppendLine($"{socketConnections.Count} connections, {CurrentSubscriptions} subscriptions, kbps: {IncomingKbps}");
+            foreach(var connection in socketConnections)
+            {
+                sb.AppendLine($"  Connection {connection.Key}: {connection.Value.SubscriptionCount} subscriptions, status: {connection.Value.Status}, authenticated: {connection.Value.Authenticated}, kbps: {connection.Value.IncomingKbps}");
+                foreach (var subscription in connection.Value.Subscriptions)
+                    sb.AppendLine($"    Subscription {subscription.Id}, authenticated: {subscription.Authenticated}, confirmed: {subscription.Confirmed}");
+            }
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Dispose the client
+        /// </summary>
+        public override void Dispose()
+        {
+            disposing = true;
+            periodicEvent?.Set();
+            periodicEvent?.Dispose();
+            if (socketConnections.Sum(s => s.Value.SubscriptionCount) > 0)
+            {
+                log.Write(LogLevel.Debug, "Disposing socket client, closing all subscriptions");
+                _ = UnsubscribeAllAsync();
+            }
+            semaphoreSlim?.Dispose();
+            base.Dispose();
         }
     }
 }

CryptoExchange.Net/Clients/RestApiClient.cs

@@ -1,593 +1,74 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Linq;
-using System.Net;
-using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Logging;
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
-using CryptoExchange.Net.Requests;
 using Microsoft.Extensions.Logging;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 
 namespace CryptoExchange.Net
 {
     /// <summary>
     /// Base rest API client for interacting with a REST API
     /// </summary>
-    public abstract class RestApiClient : BaseApiClient, IRestApiClient
+    public abstract class RestApiClient: BaseApiClient
     {
-        /// <inheritdoc />
-        public IRequestFactory RequestFactory { get; set; } = new RequestFactory();
+        /// <summary>
+        /// Get time sync info for an API client
+        /// </summary>
+        /// <returns></returns>
+        public abstract TimeSyncInfo GetTimeSyncInfo();
+        
+        /// <summary>
+        /// Get time offset for an API client
+        /// </summary>
+        /// <returns></returns>
+        public abstract TimeSpan GetTimeOffset();
 
-        /// <inheritdoc />
-        public abstract TimeSyncInfo? GetTimeSyncInfo();
-
-        /// <inheritdoc />
-        public abstract TimeSpan? GetTimeOffset();
-
-        /// <inheritdoc />
+        /// <summary>
+        /// Total amount of requests made with this API client
+        /// </summary>
         public int TotalRequestsMade { get; set; }
 
         /// <summary>
-        /// Request headers to be sent with each request
+        /// Options for this client
         /// </summary>
-        protected Dictionary<string, string>? StandardRequestHeaders { get; set; }
+        public new RestApiClientOptions Options => (RestApiClientOptions)base.Options;
 
         /// <summary>
         /// List of rate limiters
         /// </summary>
         internal IEnumerable<IRateLimiter> RateLimiters { get; }
 
-        /// <inheritdoc />
-        public new RestExchangeOptions ClientOptions => (RestExchangeOptions)base.ClientOptions;
-
-        /// <inheritdoc />
-        public new RestApiOptions ApiOptions => (RestApiOptions)base.ApiOptions;
-
         /// <summary>
         /// ctor
         /// </summary>
-        /// <param name="logger">Logger</param>
-        /// <param name="httpClient">HttpClient to use</param>
-        /// <param name="baseAddress">Base address for this API client</param>
         /// <param name="options">The base client options</param>
         /// <param name="apiOptions">The Api client options</param>
-        public RestApiClient(ILogger logger, HttpClient? httpClient, string baseAddress, RestExchangeOptions options, RestApiOptions apiOptions) 
-            : base(logger, 
-                  apiOptions.OutputOriginalData ?? options.OutputOriginalData, 
-                  apiOptions.ApiCredentials ?? options.ApiCredentials,
-                  baseAddress,
-                  options,
-                  apiOptions)
+        public RestApiClient(BaseRestClientOptions options, RestApiClientOptions apiOptions): base(options, apiOptions)
         {
             var rateLimiters = new List<IRateLimiter>();
             foreach (var rateLimiter in apiOptions.RateLimiters)
                 rateLimiters.Add(rateLimiter);
             RateLimiters = rateLimiters;
-
-            RequestFactory.Configure(options.Proxy, options.RequestTimeout, httpClient);
-        }
-
-        /// <summary>
-        /// Execute a request to the uri and returns if it was successful
-        /// </summary>
-        /// <param name="uri">The uri to send the request to</param>
-        /// <param name="method">The method of the request</param>
-        /// <param name="cancellationToken">Cancellation token</param>
-        /// <param name="parameters">The parameters of the request</param>
-        /// <param name="signed">Whether or not the request should be authenticated</param>
-        /// <param name="parameterPosition">Where the parameters should be placed, overwrites the value set in the client</param>
-        /// <param name="arraySerialization">How array parameters should be serialized, overwrites the value set in the client</param>
-        /// <param name="requestWeight">Credits used for the request</param>
-        /// <param name="deserializer">The JsonSerializer to use for deserialization</param>
-        /// <param name="additionalHeaders">Additional headers to send with the request</param>
-        /// <param name="ignoreRatelimit">Ignore rate limits for this request</param>
-        /// <returns></returns>
-        [return: NotNull]
-        protected virtual async Task<WebCallResult> SendRequestAsync(
-            Uri uri,
-            HttpMethod method,
-            CancellationToken cancellationToken,
-            Dictionary<string, object>? parameters = null,
-            bool signed = false,
-            HttpMethodParameterPosition? parameterPosition = null,
-            ArrayParametersSerialization? arraySerialization = null,
-            int requestWeight = 1,
-            JsonSerializer? deserializer = null,
-            Dictionary<string, string>? additionalHeaders = null,
-            bool ignoreRatelimit = false)
-        {
-            int currentTry = 0;
-            while (true)
-            {
-                currentTry++;
-                var request = await PrepareRequestAsync(uri, method, cancellationToken, parameters, signed, parameterPosition, arraySerialization, requestWeight, deserializer, additionalHeaders, ignoreRatelimit).ConfigureAwait(false);
-                if (!request)
-                    return new WebCallResult(request.Error!);
-
-                var result = await GetResponseAsync<object>(request.Data, deserializer, cancellationToken, true).ConfigureAwait(false);
-                if (await ShouldRetryRequestAsync(result, currentTry).ConfigureAwait(false))
-                    continue;
-
-                return result.AsDataless();
-            }
-        }
-
-        /// <summary>
-        /// Execute a request to the uri and deserialize the response into the provided type parameter
-        /// </summary>
-        /// <typeparam name="T">The type to deserialize into</typeparam>
-        /// <param name="uri">The uri to send the request to</param>
-        /// <param name="method">The method of the request</param>
-        /// <param name="cancellationToken">Cancellation token</param>
-        /// <param name="parameters">The parameters of the request</param>
-        /// <param name="signed">Whether or not the request should be authenticated</param>
-        /// <param name="parameterPosition">Where the parameters should be placed, overwrites the value set in the client</param>
-        /// <param name="arraySerialization">How array parameters should be serialized, overwrites the value set in the client</param>
-        /// <param name="requestWeight">Credits used for the request</param>
-        /// <param name="deserializer">The JsonSerializer to use for deserialization</param>
-        /// <param name="additionalHeaders">Additional headers to send with the request</param>
-        /// <param name="ignoreRatelimit">Ignore rate limits for this request</param>
-        /// <returns></returns>
-        [return: NotNull]
-        protected virtual async Task<WebCallResult<T>> SendRequestAsync<T>(
-            Uri uri,
-            HttpMethod method,
-            CancellationToken cancellationToken,
-            Dictionary<string, object>? parameters = null,
-            bool signed = false,
-            HttpMethodParameterPosition? parameterPosition = null,
-            ArrayParametersSerialization? arraySerialization = null,
-            int requestWeight = 1,
-            JsonSerializer? deserializer = null,
-            Dictionary<string, string>? additionalHeaders = null,
-            bool ignoreRatelimit = false
-            ) where T : class
-        {
-            int currentTry = 0;
-            while (true)
-            {
-                currentTry++;
-                var request = await PrepareRequestAsync(uri, method, cancellationToken, parameters, signed, parameterPosition, arraySerialization, requestWeight, deserializer, additionalHeaders, ignoreRatelimit).ConfigureAwait(false);
-                if (!request)
-                    return new WebCallResult<T>(request.Error!);
-
-                var result = await GetResponseAsync<T>(request.Data, deserializer, cancellationToken, false).ConfigureAwait(false);
-                if (await ShouldRetryRequestAsync(result, currentTry).ConfigureAwait(false))
-                    continue;
-
-                return result;
-            }
-        }
-
-        /// <summary>
-        /// Prepares a request to be sent to the server
-        /// </summary>
-        /// <param name="uri">The uri to send the request to</param>
-        /// <param name="method">The method of the request</param>
-        /// <param name="cancellationToken">Cancellation token</param>
-        /// <param name="parameters">The parameters of the request</param>
-        /// <param name="signed">Whether or not the request should be authenticated</param>
-        /// <param name="parameterPosition">Where the parameters should be placed, overwrites the value set in the client</param>
-        /// <param name="arraySerialization">How array parameters should be serialized, overwrites the value set in the client</param>
-        /// <param name="requestWeight">Credits used for the request</param>
-        /// <param name="deserializer">The JsonSerializer to use for deserialization</param>
-        /// <param name="additionalHeaders">Additional headers to send with the request</param>
-        /// <param name="ignoreRatelimit">Ignore rate limits for this request</param>
-        /// <returns></returns>
-        protected virtual async Task<CallResult<IRequest>> PrepareRequestAsync(
-            Uri uri,
-            HttpMethod method,
-            CancellationToken cancellationToken,
-            Dictionary<string, object>? parameters = null,
-            bool signed = false,
-            HttpMethodParameterPosition? parameterPosition = null,
-            ArrayParametersSerialization? arraySerialization = null,
-            int requestWeight = 1,
-            JsonSerializer? deserializer = null,
-            Dictionary<string, string>? additionalHeaders = null,
-            bool ignoreRatelimit = false)
-        {
-            var requestId = ExchangeHelpers.NextId();
-
-            if (signed)
-            {
-                var syncTask = SyncTimeAsync();
-                var timeSyncInfo = GetTimeSyncInfo();
-
-                if (timeSyncInfo != null && timeSyncInfo.TimeSyncState.LastSyncTime == default)
-                {
-                    // Initially with first request we'll need to wait for the time syncing, if it's not the first request we can just continue
-                    var syncTimeResult = await syncTask.ConfigureAwait(false);
-                    if (!syncTimeResult)
-                    {
-                        _logger.Log(LogLevel.Debug, $"[{requestId}] Failed to sync time, aborting request: " + syncTimeResult.Error);
-                        return syncTimeResult.As<IRequest>(default);
-                    }
-                }
-            }
-
-            if (!ignoreRatelimit)
-            {
-                foreach (var limiter in RateLimiters)
-                {
-                    var limitResult = await limiter.LimitRequestAsync(_logger, uri.AbsolutePath, method, signed, ApiOptions.ApiCredentials?.Key ?? ClientOptions.ApiCredentials?.Key, ApiOptions.RateLimitingBehaviour, requestWeight, cancellationToken).ConfigureAwait(false);
-                    if (!limitResult.Success)
-                        return new CallResult<IRequest>(limitResult.Error!);
-                }
-            }
-
-            if (signed && AuthenticationProvider == null)
-            {
-                _logger.Log(LogLevel.Warning, $"[{requestId}] Request {uri.AbsolutePath} failed because no ApiCredentials were provided");
-                return new CallResult<IRequest>(new NoApiCredentialsError());
-            }
-
-            _logger.Log(LogLevel.Information, $"[{requestId}] Creating request for " + uri);
-            var paramsPosition = parameterPosition ?? ParameterPositions[method];
-            var request = ConstructRequest(uri, method, parameters?.OrderBy(p => p.Key).ToDictionary(p => p.Key, p => p.Value), signed, paramsPosition, arraySerialization ?? this.arraySerialization, requestId, additionalHeaders);
-
-            string? paramString = "";
-            if (paramsPosition == HttpMethodParameterPosition.InBody)
-                paramString = $" with request body '{request.Content}'";
-
-            var headers = request.GetHeaders();
-            if (headers.Any())
-                paramString += " with headers " + string.Join(", ", headers.Select(h => h.Key + $"=[{string.Join(",", h.Value)}]"));
-
-            TotalRequestsMade++;
-            _logger.Log(LogLevel.Trace, $"[{requestId}] Sending {method}{(signed ? " signed" : "")} request to {request.Uri}{paramString ?? " "}");
-            return new CallResult<IRequest>(request);
-        }
-
-        /// <summary>
-        /// Executes the request and returns the result deserialized into the type parameter class
-        /// </summary>
-        /// <param name="request">The request object to execute</param>
-        /// <param name="deserializer">The JsonSerializer to use for deserialization</param>
-        /// <param name="cancellationToken">Cancellation token</param>
-        /// <param name="expectedEmptyResponse">If an empty response is expected</param>
-        /// <returns></returns>
-        protected virtual async Task<WebCallResult<T>> GetResponseAsync<T>(
-            IRequest request,
-            JsonSerializer? deserializer,
-            CancellationToken cancellationToken,
-            bool expectedEmptyResponse)
-        {
-            try
-            {
-                var sw = Stopwatch.StartNew();
-                var response = await request.GetResponseAsync(cancellationToken).ConfigureAwait(false);
-                sw.Stop();
-                var statusCode = response.StatusCode;
-                var headers = response.ResponseHeaders;
-                var responseLength = response.ContentLength;
-                var responseStream = await response.GetResponseStreamAsync().ConfigureAwait(false);
-                if (response.IsSuccessStatusCode)
-                {
-                    // If we have to manually parse error responses (can't rely on HttpStatusCode) we'll need to read the full
-                    // response before being able to deserialize it into the resulting type since we don't know if it an error response or data
-                    if (manualParseError)
-                    {
-                        using var reader = new StreamReader(responseStream);
-                        var data = await reader.ReadToEndAsync().ConfigureAwait(false);
-                        responseLength ??= data.Length;
-                        responseStream.Close();
-                        response.Close();
-                        _logger.Log(LogLevel.Debug, $"[{request.RequestId}] Response received in {sw.ElapsedMilliseconds}ms{(OutputOriginalData ? (": " + data) : "")}");
-
-                        if (!expectedEmptyResponse)
-                        {
-                            // Validate if it is valid json. Sometimes other data will be returned, 502 error html pages for example
-                            var parseResult = ValidateJson(data);
-                            if (!parseResult.Success)
-                                return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? data : null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, parseResult.Error!);
-
-                            // Let the library implementation see if it is an error response, and if so parse the error
-                            var error = await TryParseErrorAsync(parseResult.Data).ConfigureAwait(false);
-                            if (error != null)
-                                return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? data : null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, error!);
-
-                            // Not an error, so continue deserializing
-                            var deserializeResult = Deserialize<T>(parseResult.Data, deserializer, request.RequestId);
-                            return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? data : null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), deserializeResult.Data, deserializeResult.Error);
-                        }
-                        else
-                        {
-                            if (!string.IsNullOrEmpty(data))
-                            {
-                                var parseResult = ValidateJson(data);
-                                if (!parseResult.Success)
-                                    // Not empty, and not json
-                                    return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? data : null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, parseResult.Error!);
-
-                                var error = await TryParseErrorAsync(parseResult.Data).ConfigureAwait(false);
-                                if (error != null)
-                                    // Error response
-                                    return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? data : null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, error!);
-                            }
-
-                            // Empty success response; okay
-                            return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? data : null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, default);
-                        }
-                    }
-                    else
-                    {
-                        if (expectedEmptyResponse)
-                        {
-                            // We expected an empty response and the request is successful and don't manually parse errors, so assume it's correct
-                            responseStream.Close();
-                            response.Close();
-
-                            return new WebCallResult<T>(statusCode, headers, sw.Elapsed, 0, null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, null);
-                        }
-
-                        // Success status code, and we don't have to check for errors. Continue deserializing directly from the stream
-                        var desResult = await DeserializeAsync<T>(responseStream, deserializer, request.RequestId, sw.ElapsedMilliseconds).ConfigureAwait(false);
-                        responseStream.Close();
-                        response.Close();
-
-                        return new WebCallResult<T>(statusCode, headers, sw.Elapsed, responseLength, OutputOriginalData ? desResult.OriginalData : null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), desResult.Data, desResult.Error);
-                    }
-                }
-                else
-                {
-                    // Http status code indicates error
-                    using var reader = new StreamReader(responseStream);
-                    var data = await reader.ReadToEndAsync().ConfigureAwait(false);
-                    _logger.Log(LogLevel.Warning, $"[{request.RequestId}] Error received in {sw.ElapsedMilliseconds}ms: {data}");
-                    responseStream.Close();
-                    response.Close();
-
-                    Error error;
-                    if (response.StatusCode == (HttpStatusCode)418 || response.StatusCode == (HttpStatusCode)429)
-                        error = ParseRateLimitResponse((int)response.StatusCode, response.ResponseHeaders, data);
-                    else
-                        error = ParseErrorResponse((int)response.StatusCode, response.ResponseHeaders, data);
-
-                    if (error.Code == null || error.Code == 0)
-                        error.Code = (int)response.StatusCode;
-                    return new WebCallResult<T>(statusCode, headers, sw.Elapsed, data.Length, data, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, error);
-                }
-            }
-            catch (HttpRequestException requestException)
-            {
-                // Request exception, can't reach server for instance
-                var exceptionInfo = requestException.ToLogString();
-                _logger.Log(LogLevel.Warning, $"[{request.RequestId}] Request exception: " + exceptionInfo);
-                return new WebCallResult<T>(null, null, null, null, null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, new WebError(exceptionInfo));
-            }
-            catch (OperationCanceledException canceledException)
-            {
-                if (cancellationToken != default && canceledException.CancellationToken == cancellationToken)
-                {
-                    // Cancellation token canceled by caller
-                    _logger.Log(LogLevel.Warning, $"[{request.RequestId}] Request canceled by cancellation token");
-                    return new WebCallResult<T>(null, null, null, null, null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, new CancellationRequestedError());
-                }
-                else
-                {
-                    // Request timed out
-                    _logger.Log(LogLevel.Warning, $"[{request.RequestId}] Request timed out: " + canceledException.ToLogString());
-                    return new WebCallResult<T>(null, null, null, null, null, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, new WebError($"[{request.RequestId}] Request timed out"));
-                }
-            }
-        }
-
-        /// <summary>
-        /// Can be used to parse an error even though response status indicates success. Some apis always return 200 OK, even though there is an error.
-        /// When setting manualParseError to true this method will be called for each response to be able to check if the response is an error or not.
-        /// If the response is an error this method should return the parsed error, else it should return null
-        /// </summary>
-        /// <param name="data">Received data</param>
-        /// <returns>Null if not an error, Error otherwise</returns>
-        protected virtual Task<ServerError?> TryParseErrorAsync(JToken data)
-        {
-            return Task.FromResult<ServerError?>(null);
-        }
-
-        /// <summary>
-        /// Can be used to indicate that a request should be retried. Defaults to false. Make sure to retry a max number of times (based on the the tries parameter) or the request will retry forever.
-        /// Note that this is always called; even when the request might be successful
-        /// </summary>
-        /// <typeparam name="T">WebCallResult type parameter</typeparam>
-        /// <param name="callResult">The result of the call</param>
-        /// <param name="tries">The current try number</param>
-        /// <returns>True if call should retry, false if the call should return</returns>
-        protected virtual Task<bool> ShouldRetryRequestAsync<T>(WebCallResult<T> callResult, int tries) => Task.FromResult(false);
-
-        /// <summary>
-        /// Creates a request object
-        /// </summary>
-        /// <param name="uri">The uri to send the request to</param>
-        /// <param name="method">The method of the request</param>
-        /// <param name="parameters">The parameters of the request</param>
-        /// <param name="signed">Whether or not the request should be authenticated</param>
-        /// <param name="parameterPosition">Where the parameters should be placed</param>
-        /// <param name="arraySerialization">How array parameters should be serialized</param>
-        /// <param name="requestId">Unique id of a request</param>
-        /// <param name="additionalHeaders">Additional headers to send with the request</param>
-        /// <returns></returns>
-        protected virtual IRequest ConstructRequest(
-            Uri uri,
-            HttpMethod method,
-            Dictionary<string, object>? parameters,
-            bool signed,
-            HttpMethodParameterPosition parameterPosition,
-            ArrayParametersSerialization arraySerialization,
-            int requestId,
-            Dictionary<string, string>? additionalHeaders)
-        {
-            parameters ??= new Dictionary<string, object>();
-
-            for (var i = 0; i < parameters.Count; i++)
-            {
-                var kvp = parameters.ElementAt(i);
-                if (kvp.Value is Func<object> delegateValue)
-                    parameters[kvp.Key] = delegateValue();
-            }
-
-            if (parameterPosition == HttpMethodParameterPosition.InUri)
-            {
-                foreach (var parameter in parameters)
-                    uri = uri.AddQueryParmeter(parameter.Key, parameter.Value.ToString());
-            }
-
-            var headers = new Dictionary<string, string>();
-            var uriParameters = parameterPosition == HttpMethodParameterPosition.InUri ? new SortedDictionary<string, object>(parameters) : new SortedDictionary<string, object>();
-            var bodyParameters = parameterPosition == HttpMethodParameterPosition.InBody ? new SortedDictionary<string, object>(parameters) : new SortedDictionary<string, object>();
-            if (AuthenticationProvider != null)
-            {
-                try
-                {
-                    AuthenticationProvider.AuthenticateRequest(
-                        this,
-                        uri,
-                        method,
-                        parameters,
-                        signed,
-                        arraySerialization,
-                        parameterPosition,
-                        out uriParameters,
-                        out bodyParameters,
-                        out headers);
-                }
-                catch (Exception ex)
-                {
-                    throw new Exception("Failed to authenticate request, make sure your API credentials are correct", ex);
-                }
-            }
-
-            // Sanity check
-            foreach (var param in parameters)
-            {
-                if (!uriParameters.ContainsKey(param.Key) && !bodyParameters.ContainsKey(param.Key))
-                {
-                    throw new Exception($"Missing parameter {param.Key} after authentication processing. AuthenticationProvider implementation " +
-                        $"should return provided parameters in either the uri or body parameters output");
-                }
-            }
-
-            // Add the auth parameters to the uri, start with a new URI to be able to sort the parameters including the auth parameters            
-            uri = uri.SetParameters(uriParameters, arraySerialization);
-
-            var request = RequestFactory.Create(method, uri, requestId);
-            request.Accept = Constants.JsonContentHeader;
-
-            foreach (var header in headers)
-                request.AddHeader(header.Key, header.Value);
-
-            if (additionalHeaders != null)
-            {
-                foreach (var header in additionalHeaders)
-                    request.AddHeader(header.Key, header.Value);
-            }
-
-            if (StandardRequestHeaders != null)
-            {
-                foreach (var header in StandardRequestHeaders)
-                {
-                    // Only add it if it isn't overwritten
-                    if (additionalHeaders?.ContainsKey(header.Key) != true)
-                        request.AddHeader(header.Key, header.Value);
-                }
-            }
-
-            if (parameterPosition == HttpMethodParameterPosition.InBody)
-            {
-                var contentType = requestBodyFormat == RequestBodyFormat.Json ? Constants.JsonContentHeader : Constants.FormContentHeader;
-                if (bodyParameters.Any())
-                    WriteParamBody(request, bodyParameters, contentType);
-                else
-                    request.SetContent(requestBodyEmptyContent, contentType);
-            }
-
-            return request;
-        }
-
-        /// <summary>
-        /// Writes the parameters of the request to the request object body
-        /// </summary>
-        /// <param name="request">The request to set the parameters on</param>
-        /// <param name="parameters">The parameters to set</param>
-        /// <param name="contentType">The content type of the data</param>
-        protected virtual void WriteParamBody(IRequest request, SortedDictionary<string, object> parameters, string contentType)
-        {
-            if (requestBodyFormat == RequestBodyFormat.Json)
-            {
-                // Write the parameters as json in the body
-                var stringData = JsonConvert.SerializeObject(parameters);
-                request.SetContent(stringData, contentType);
-            }
-            else if (requestBodyFormat == RequestBodyFormat.FormData)
-            {
-                // Write the parameters as form data in the body
-                var stringData = parameters.ToFormData();
-                request.SetContent(stringData, contentType);
-            }
-        }
-
-        /// <summary>
-        /// Parse an error response from the server. Only used when server returns a status other than Success(200) or ratelimit error (429 or 418)
-        /// </summary>
-        /// <param name="httpStatusCode">The response status code</param>
-        /// <param name="responseHeaders">The response headers</param>
-        /// <param name="data">The response data</param>
-        /// <returns></returns>
-        protected virtual Error ParseErrorResponse(int httpStatusCode, IEnumerable<KeyValuePair<string, IEnumerable<string>>> responseHeaders, string data)
-        {
-            return new ServerError(data);
-        }
-        
-        /// <summary>
-        /// Parse a rate limit error response from the server. Only used when server returns http status 429 or 418
-        /// </summary>
-        /// <param name="httpStatusCode">The response status code</param>
-        /// <param name="responseHeaders">The response headers</param>
-        /// <param name="data">The response data</param>
-        /// <returns></returns>
-        protected virtual Error ParseRateLimitResponse(int httpStatusCode, IEnumerable<KeyValuePair<string, IEnumerable<string>>> responseHeaders, string data)
-        {
-            // Handle retry after header
-            var retryAfterHeader = responseHeaders.SingleOrDefault(r => r.Key.Equals("Retry-After", StringComparison.InvariantCultureIgnoreCase));
-            if (retryAfterHeader.Value?.Any() != true)
-                return new ServerRateLimitError(data);
-
-            var value = retryAfterHeader.Value.First();
-            if (int.TryParse(value, out var seconds))
-                return new ServerRateLimitError(data) { RetryAfter = DateTime.UtcNow.AddSeconds(seconds) };
-
-            if (DateTime.TryParse(value, out var datetime))
-                return new ServerRateLimitError(data) { RetryAfter = datetime };
-
-            return new ServerRateLimitError(data);
         }
 
         /// <summary>
         /// Retrieve the server time for the purpose of syncing time between client and server to prevent authentication issues
         /// </summary>
         /// <returns>Server time</returns>
-        protected virtual Task<WebCallResult<DateTime>> GetServerTimestampAsync() => throw new NotImplementedException();
+        protected abstract Task<WebCallResult<DateTime>> GetServerTimestampAsync();
 
         internal async Task<WebCallResult<bool>> SyncTimeAsync()
         {
             var timeSyncParams = GetTimeSyncInfo();
-            if (timeSyncParams == null)
-                return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, true, null);
-
             if (await timeSyncParams.TimeSyncState.Semaphore.WaitAsync(0).ConfigureAwait(false))
             {
                 if (!timeSyncParams.SyncTime || (DateTime.UtcNow - timeSyncParams.TimeSyncState.LastSyncTime < timeSyncParams.RecalculationInterval))
                 {
                     timeSyncParams.TimeSyncState.Semaphore.Release();
-                    return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, true, null);
+                    return new WebCallResult<bool>(null, null, null, null, null, null, null, null, true, null);
                 }
 
                 var localTime = DateTime.UtcNow;
@@ -613,10 +94,10 @@ namespace CryptoExchange.Net
                 // Calculate time offset between local and server
                 var offset = result.Data - (localTime.AddMilliseconds(result.ResponseTime!.Value.TotalMilliseconds / 2));
                 timeSyncParams.UpdateTimeOffset(offset);
-                timeSyncParams.TimeSyncState.Semaphore.Release();
+                timeSyncParams.TimeSyncState.Semaphore.Release();                
             }
 
-            return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, true, null);
+            return new WebCallResult<bool>(null, null, null, null, null, null, null, null, true, null);
         }
     }
 }

CryptoExchange.Net/Clients/SocketApiClient.cs

@@ -1,838 +1,19 @@
-using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
-using CryptoExchange.Net.Sockets;
-using Microsoft.Extensions.Logging;
-using Newtonsoft.Json.Linq;
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using static CryptoExchange.Net.Objects.RateLimiter;
 
 namespace CryptoExchange.Net
 {
     /// <summary>
     /// Base socket API client for interaction with a websocket API
     /// </summary>
-    public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
+    public abstract class SocketApiClient : BaseApiClient
     {
-        #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>
-        /// Delegate used for processing byte data received from socket connections before it is processed by handlers
-        /// </summary>
-        protected Func<byte[], string>? dataInterpreterBytes;
-
-        /// <summary>
-        /// Delegate used for processing string data received from socket connections before it is processed by handlers
-        /// </summary>
-        protected Func<string, string>? dataInterpreterString;
-
-        /// <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 Dictionary<string, Action<MessageEvent>> genericHandlers = new();
-
-        /// <summary>
-        /// The task that is sending periodic data on the websocket. Can be used for sending Ping messages every x seconds or similair. Not necesarry.
-        /// </summary>
-        protected Task? periodicTask;
-
-        /// <summary>
-        /// Wait event for the periodicTask
-        /// </summary>
-        protected AsyncResetEvent? periodicEvent;
-
-        /// <summary>
-        /// If true; data which is a response to a query will also be distributed to subscriptions
-        /// If false; data which is a response to a query won't get forwarded to subscriptions as well
-        /// </summary>
-        protected internal bool ContinueOnQueryResponse { get; protected set; }
-
-        /// <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 IEnumerable<IRateLimiter>? RateLimiters { get; set; }
-
-        /// <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.SubscriptionCount);
-            }
-        }
-
-
-        /// <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="options">The base client options</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)
+        public SocketApiClient(BaseClientOptions options, ApiClientOptions apiOptions): base(options, apiOptions)
         {
-            var rateLimiters = new List<IRateLimiter>();
-            foreach (var rateLimiter in apiOptions.RateLimiters)
-                rateLimiters.Add(rateLimiter);
-            RateLimiters = rateLimiters;
-        }
-
-        /// <summary>
-        /// Set a delegate to be used for processing data received from socket connections before it is processed by handlers
-        /// </summary>
-        /// <param name="byteHandler">Handler for byte data</param>
-        /// <param name="stringHandler">Handler for string data</param>
-        protected void SetDataInterpreter(Func<byte[], string>? byteHandler, Func<string, string>? stringHandler)
-        {
-            dataInterpreterBytes = byteHandler;
-            dataInterpreterString = stringHandler;
-        }
-
-        /// <summary>
-        /// Connect to an url and listen for data on the BaseAddress
-        /// </summary>
-        /// <typeparam name="T">The type of the expected data</typeparam>
-        /// <param name="request">The optional request object to send, will be serialized to json</param>
-        /// <param name="identifier">The identifier to use, necessary if no request object is sent</param>
-        /// <param name="authenticated">If the subscription is to an authenticated endpoint</param>
-        /// <param name="dataHandler">The handler of update data</param>
-        /// <param name="ct">Cancellation token for closing this subscription</param>
-        /// <returns></returns>
-        protected virtual Task<CallResult<UpdateSubscription>> SubscribeAsync<T>(object? request, string? identifier, bool authenticated, Action<DataEvent<T>> dataHandler, CancellationToken ct)
-        {
-            return SubscribeAsync(BaseAddress, request, identifier, authenticated, dataHandler, ct);
-        }
-
-        /// <summary>
-        /// Connect to an url and listen for data
-        /// </summary>
-        /// <typeparam name="T">The type of the expected data</typeparam>
-        /// <param name="url">The URL to connect to</param>
-        /// <param name="request">The optional request object to send, will be serialized to json</param>
-        /// <param name="identifier">The identifier to use, necessary if no request object is sent</param>
-        /// <param name="authenticated">If the subscription is to an authenticated endpoint</param>
-        /// <param name="dataHandler">The handler of update data</param>
-        /// <param name="ct">Cancellation token for closing this subscription</param>
-        /// <returns></returns>
-        protected virtual async Task<CallResult<UpdateSubscription>> SubscribeAsync<T>(string url, object? request, string? identifier, bool authenticated, Action<DataEvent<T>> dataHandler, CancellationToken ct)
-        {
-            if (_disposing)
-                return new CallResult<UpdateSubscription>(new InvalidOperationError("Client disposed, can't subscribe"));
-
-            SocketConnection socketConnection;
-            SocketSubscription? subscription;
-            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, authenticated).ConfigureAwait(false);
-                    if (!socketResult)
-                        return socketResult.As<UpdateSubscription>(null);
-
-                    socketConnection = socketResult.Data;
-
-                    // Add a subscription on the socket connection
-                    subscription = AddSubscription(request, identifier, true, socketConnection, dataHandler, authenticated);
-                    if (subscription == null)
-                    {
-                        _logger.Log(LogLevel.Trace, $"Socket {socketConnection.SocketId} failed to add subscription, retrying on different connection");
-                        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, authenticated).ConfigureAwait(false);
-                    if (!connectResult)
-                        return new CallResult<UpdateSubscription>(connectResult.Error!);
-
-                    break;
-                }
-            }
-            finally
-            {
-                if (!released)
-                    semaphoreSlim.Release();
-            }
-
-            if (socketConnection.PausedActivity)
-            {
-                _logger.Log(LogLevel.Warning, $"Socket {socketConnection.SocketId} has been paused, can't subscribe at this moment");
-                return new CallResult<UpdateSubscription>(new ServerError("Socket is paused"));
-            }
-
-            if (request != null)
-            {
-                // Send the request and wait for answer
-                var subResult = await SubscribeAndWaitAsync(socketConnection, request, subscription).ConfigureAwait(false);
-                if (!subResult)
-                {
-                    _logger.Log(LogLevel.Warning, $"Socket {socketConnection.SocketId} failed to subscribe: {subResult.Error}");
-                    await socketConnection.CloseAsync(subscription).ConfigureAwait(false);
-                    return new CallResult<UpdateSubscription>(subResult.Error!);
-                }
-            }
-            else
-            {
-                // No request to be sent, so just mark the subscription as comfirmed
-                subscription.Confirmed = true;
-            }
-
-            if (ct != default)
-            {
-                subscription.CancellationTokenRegistration = ct.Register(async () =>
-                {
-                    _logger.Log(LogLevel.Information, $"Socket {socketConnection.SocketId} Cancellation token set, closing subscription");
-                    await socketConnection.CloseAsync(subscription).ConfigureAwait(false);
-                }, false);
-            }
-
-            _logger.Log(LogLevel.Information, $"Socket {socketConnection.SocketId} subscription {subscription.Id} completed successfully");
-            return new CallResult<UpdateSubscription>(new UpdateSubscription(socketConnection, subscription));
-        }
-
-        /// <summary>
-        /// Sends the subscribe request and waits for a response to that request
-        /// </summary>
-        /// <param name="socketConnection">The connection to send the request on</param>
-        /// <param name="request">The request to send, will be serialized to json</param>
-        /// <param name="subscription">The subscription the request is for</param>
-        /// <returns></returns>
-        protected internal virtual async Task<CallResult<bool>> SubscribeAndWaitAsync(SocketConnection socketConnection, object request, SocketSubscription subscription)
-        {
-            CallResult<object>? callResult = null;
-            await socketConnection.SendAndWaitAsync(request, ClientOptions.RequestTimeout, subscription, 1, data => HandleSubscriptionResponse(socketConnection, subscription, request, data, out callResult)).ConfigureAwait(false);
-
-            if (callResult?.Success == true)
-            {
-                subscription.Confirmed = true;
-                return new CallResult<bool>(true);
-            }
-
-            if (callResult == null)
-                return new CallResult<bool>(new ServerError("No response on subscription request received"));
-
-            return new CallResult<bool>(callResult.Error!);
-        }
-
-        /// <summary>
-        /// Send a query on a socket connection to the BaseAddress and wait for the response
-        /// </summary>
-        /// <typeparam name="T">Expected result type</typeparam>
-        /// <param name="request">The request to send, will be serialized to json</param>
-        /// <param name="authenticated">If the query is to an authenticated endpoint</param>
-        /// <param name="weight">Weight of the request</param>
-        /// <returns></returns>
-        protected virtual Task<CallResult<T>> QueryAsync<T>(object request, bool authenticated, int weight = 1)
-        {
-            return QueryAsync<T>(BaseAddress, request, authenticated, weight);
-        }
-
-        /// <summary>
-        /// Send a query on a socket connection and wait for the response
-        /// </summary>
-        /// <typeparam name="T">The expected result type</typeparam>
-        /// <param name="url">The url for the request</param>
-        /// <param name="request">The request to send</param>
-        /// <param name="authenticated">Whether the socket should be authenticated</param>
-        /// <param name="weight">Weight of the request</param>
-        /// <returns></returns>
-        protected virtual async Task<CallResult<T>> QueryAsync<T>(string url, object request, bool authenticated, int weight = 1)
-        {
-            if (_disposing)
-                return new CallResult<T>(new InvalidOperationError("Client disposed, can't query"));
-
-            SocketConnection socketConnection;
-            var released = false;
-            await semaphoreSlim.WaitAsync().ConfigureAwait(false);
-            try
-            {
-                var socketResult = await GetSocketConnection(url, authenticated).ConfigureAwait(false);
-                if (!socketResult)
-                    return socketResult.As<T>(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, authenticated).ConfigureAwait(false);
-                if (!connectResult)
-                    return new CallResult<T>(connectResult.Error!);
-            }
-            finally
-            {
-                if (!released)
-                    semaphoreSlim.Release();
-            }
-
-            if (socketConnection.PausedActivity)
-            {
-                _logger.Log(LogLevel.Warning, $"Socket {socketConnection.SocketId} has been paused, can't send query at this moment");
-                return new CallResult<T>(new ServerError("Socket is paused"));
-            }
-
-            return await QueryAndWaitAsync<T>(socketConnection, request, weight).ConfigureAwait(false);
-        }
-
-        /// <summary>
-        /// Sends the query request and waits for the result
-        /// </summary>
-        /// <typeparam name="T">The expected result type</typeparam>
-        /// <param name="socket">The connection to send and wait on</param>
-        /// <param name="request">The request to send</param>
-        /// <param name="weight">The weight of the query</param>
-        /// <returns></returns>
-        protected virtual async Task<CallResult<T>> QueryAndWaitAsync<T>(SocketConnection socket, object request, int weight)
-        {
-            var dataResult = new CallResult<T>(new ServerError("No response on query received"));
-            await socket.SendAndWaitAsync(request, ClientOptions.RequestTimeout, null, weight, data =>
-            {
-                if (!HandleQueryResponse<T>(socket, request, data, out var callResult))
-                    return false;
-
-                dataResult = callResult;
-                return true;
-            }).ConfigureAwait(false);
-
-            return dataResult;
-        }
-
-        /// <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<bool>> ConnectIfNeededAsync(SocketConnection socket, bool authenticated)
-        {
-            if (socket.Connected)
-                return new CallResult<bool>(true);
-
-            var connectResult = await ConnectSocketAsync(socket).ConfigureAwait(false);
-            if (!connectResult)
-                return new CallResult<bool>(connectResult.Error!);
-
-            if (ClientOptions.DelayAfterConnect != TimeSpan.Zero)
-                await Task.Delay(ClientOptions.DelayAfterConnect).ConfigureAwait(false);
-
-            if (!authenticated || socket.Authenticated)
-                return new CallResult<bool>(true);
-
-            _logger.Log(LogLevel.Debug, $"Attempting to authenticate {socket.SocketId}");
-            var result = await AuthenticateSocketAsync(socket).ConfigureAwait(false);
-            if (!result)
-            {
-                _logger.Log(LogLevel.Warning, $"Socket {socket.SocketId} authentication failed");
-                if (socket.Connected)
-                    await socket.CloseAsync().ConfigureAwait(false);
-
-                result.Error!.Message = "Authentication failed: " + result.Error.Message;
-                return new CallResult<bool>(result.Error);
-            }
-
-            socket.Authenticated = true;
-            return new CallResult<bool>(true);
-        }
-
-        /// <summary>
-        /// The socketConnection received data (the data JToken parameter). The implementation of this method should check if the received data is a response to the query that was send (the request parameter).
-        /// For example; A query is sent in a request message with an Id parameter with value 10. The socket receives data and calls this method to see if the data it received is an
-        /// anwser to any query that was done. The implementation of this method should check if the response.Id == request.Id to see if they match (assuming the api has some sort of Id tracking on messages,
-        /// if not some other method has be implemented to match the messages).
-        /// If the messages match, the callResult out parameter should be set with the deserialized data in the from of (T) and return true.
-        /// </summary>
-        /// <typeparam name="T">The type of response that is expected on the query</typeparam>
-        /// <param name="socketConnection">The socket connection</param>
-        /// <param name="request">The request that a response is awaited for</param>
-        /// <param name="data">The message received from the server</param>
-        /// <param name="callResult">The interpretation (null if message wasn't a response to the request)</param>
-        /// <returns>True if the message was a response to the query</returns>
-        protected internal abstract bool HandleQueryResponse<T>(SocketConnection socketConnection, object request, JToken data, [NotNullWhen(true)] out CallResult<T>? callResult);
-        
-        /// <summary>
-        /// The socketConnection received data (the data JToken parameter). The implementation of this method should check if the received data is a response to the subscription request that was send (the request parameter).
-        /// For example; A subscribe request message is send with an Id parameter with value 10. The socket receives data and calls this method to see if the data it received is an
-        /// anwser to any subscription request that was done. The implementation of this method should check if the response.Id == request.Id to see if they match (assuming the api has some sort of Id tracking on messages,
-        /// if not some other method has be implemented to match the messages).
-        /// If the messages match, the callResult out parameter should be set with the deserialized data in the from of (T) and return true.
-        /// </summary>
-        /// <param name="socketConnection">The socket connection</param>
-        /// <param name="subscription">A subscription that waiting for a subscription response</param>
-        /// <param name="request">The request that the subscription sent</param>
-        /// <param name="data">The message received from the server</param>
-        /// <param name="callResult">The interpretation (null if message wasn't a response to the request)</param>
-        /// <returns>True if the message was a response to the subscription request</returns>
-        protected internal abstract bool HandleSubscriptionResponse(SocketConnection socketConnection, SocketSubscription subscription, object request, JToken data, out CallResult<object>? callResult);
-        
-        /// <summary>
-        /// Needs to check if a received message matches a handler by request. After subscribing data message will come in. These data messages need to be matched to a specific connection
-        /// to pass the correct data to the correct handler. The implementation of this method should check if the message received matches the subscribe request that was sent.
-        /// </summary>
-        /// <param name="socketConnection">The socket connection the message was recieved on</param>
-        /// <param name="message">The received data</param>
-        /// <param name="request">The subscription request</param>
-        /// <returns>True if the message is for the subscription which sent the request</returns>
-        protected internal abstract bool MessageMatchesHandler(SocketConnection socketConnection, JToken message, object request);
-        
-        /// <summary>
-        /// Needs to check if a received message matches a handler by identifier. Generally used by GenericHandlers. For example; a generic handler is registered which handles ping messages
-        /// from the server. This method should check if the message received is a ping message and the identifer is the identifier of the GenericHandler
-        /// </summary>
-        /// <param name="socketConnection">The socket connection the message was recieved on</param>
-        /// <param name="message">The received data</param>
-        /// <param name="identifier">The string identifier of the handler</param>
-        /// <returns>True if the message is for the handler which has the identifier</returns>
-        protected internal abstract bool MessageMatchesHandler(SocketConnection socketConnection, JToken message, string identifier);
-        
-        /// <summary>
-        /// Needs to authenticate the socket so authenticated queries/subscriptions can be made on this socket connection
-        /// </summary>
-        /// <param name="socketConnection">The socket connection that should be authenticated</param>
-        /// <returns></returns>
-        protected internal abstract Task<CallResult<bool>> AuthenticateSocketAsync(SocketConnection socketConnection);
-        
-        /// <summary>
-        /// Needs to unsubscribe a subscription, typically by sending an unsubscribe request. If multiple subscriptions per socket is not allowed this can just return since the socket will be closed anyway
-        /// </summary>
-        /// <param name="connection">The connection on which to unsubscribe</param>
-        /// <param name="subscriptionToUnsub">The subscription to unsubscribe</param>
-        /// <returns></returns>
-        protected internal abstract Task<bool> UnsubscribeAsync(SocketConnection connection, SocketSubscription subscriptionToUnsub);
-
-        /// <summary>
-        /// Optional handler to interpolate data before sending it to the handlers
-        /// </summary>
-        /// <param name="message"></param>
-        /// <returns></returns>
-        protected internal virtual JToken ProcessTokenData(JToken message)
-        {
-            return message;
-        }
-
-        /// <summary>
-        /// Add a subscription to a connection
-        /// </summary>
-        /// <typeparam name="T">The type of data the subscription expects</typeparam>
-        /// <param name="request">The request of the subscription</param>
-        /// <param name="identifier">The identifier of the subscription (can be null if request param is used)</param>
-        /// <param name="userSubscription">Whether or not this is a user subscription (counts towards the max amount of handlers on a socket)</param>
-        /// <param name="connection">The socket connection the handler is on</param>
-        /// <param name="dataHandler">The handler of the data received</param>
-        /// <param name="authenticated">Whether the subscription needs authentication</param>
-        /// <returns></returns>
-        protected virtual SocketSubscription? AddSubscription<T>(object? request, string? identifier, bool userSubscription, SocketConnection connection, Action<DataEvent<T>> dataHandler, bool authenticated)
-        {
-            void InternalHandler(MessageEvent messageEvent)
-            {
-                if (typeof(T) == typeof(string))
-                {
-                    var stringData = (T)Convert.ChangeType(messageEvent.JsonData.ToString(), typeof(T));
-                    dataHandler(new DataEvent<T>(stringData, null, OutputOriginalData ? messageEvent.OriginalData : null, messageEvent.ReceivedTimestamp));
-                    return;
-                }
-
-                var desResult = Deserialize<T>(messageEvent.JsonData);
-                if (!desResult)
-                {
-                    _logger.Log(LogLevel.Warning, $"Socket {connection.SocketId} Failed to deserialize data into type {typeof(T)}: {desResult.Error}");
-                    return;
-                }
-
-                dataHandler(new DataEvent<T>(desResult.Data, null, OutputOriginalData ? messageEvent.OriginalData : null, messageEvent.ReceivedTimestamp));
-            }
-
-            var subscription = request == null
-                ? SocketSubscription.CreateForIdentifier(ExchangeHelpers.NextId(), identifier!, userSubscription, authenticated, InternalHandler)
-                : SocketSubscription.CreateForRequest(ExchangeHelpers.NextId(), request, userSubscription, authenticated, InternalHandler);
-            if (!connection.AddSubscription(subscription))
-                return null;
-            return subscription;
-        }
-
-        /// <summary>
-        /// Adds a generic message handler. Used for example to reply to ping requests
-        /// </summary>
-        /// <param name="identifier">The name of the request handler. Needs to be unique</param>
-        /// <param name="action">The action to execute when receiving a message for this handler (checked by <see cref="MessageMatchesHandler(SocketConnection, Newtonsoft.Json.Linq.JToken,string)"/>)</param>
-        protected void AddGenericHandler(string identifier, Action<MessageEvent> action)
-        {
-            genericHandlers.Add(identifier, action);
-            var subscription = SocketSubscription.CreateForIdentifier(ExchangeHelpers.NextId(), identifier, false, false, action);
-            foreach (var connection in socketConnections.Values)
-                connection.AddSubscription(subscription);
-        }
-
-        /// <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>
-        public virtual Task<Uri?> GetReconnectUriAsync(SocketConnection connection)
-        {
-            return Task.FromResult<Uri?>(connection.ConnectionUri);
-        }
-
-        /// <summary>
-        /// Update the original request to send when the connection is restored after disconnecting. Can be used to update an authentication token for example.
-        /// </summary>
-        /// <param name="request">The original request</param>
-        /// <returns></returns>
-        public virtual Task<CallResult<object>> RevitalizeRequestAsync(object request)
-        {
-            return Task.FromResult(new CallResult<object>(request));
-        }
-
-        /// <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>
-        /// <returns></returns>
-        protected virtual async Task<CallResult<SocketConnection>> GetSocketConnection(string address, bool authenticated)
-        {
-            var socketResult = 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) && s.Value.Connected).OrderBy(s => s.Value.SubscriptionCount).FirstOrDefault();
-            var result = socketResult.Equals(default(KeyValuePair<int, SocketConnection>)) ? null : socketResult.Value;
-            if (result != null)
-            {
-                if (result.SubscriptionCount < ClientOptions.SocketSubscriptionsCombineTarget || (socketConnections.Count >= (ApiOptions.MaxSocketConnections ?? ClientOptions.MaxSocketConnections) && socketConnections.All(s => s.Value.SubscriptionCount >= 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>(result);
-                }
-            }
-
-            var connectionAddress = await GetConnectionUrlAsync(address, authenticated).ConfigureAwait(false);
-            if (!connectionAddress)
-            {
-                _logger.Log(LogLevel.Warning, $"Failed to determine connection url: " + connectionAddress.Error);
-                return connectionAddress.As<SocketConnection>(null);
-            }
-
-            if (connectionAddress.Data != address)
-                _logger.Log(LogLevel.Debug, $"Connection address set to " + connectionAddress.Data);
-
-            // Create new socket
-            var socket = CreateSocket(connectionAddress.Data!);
-            var socketConnection = new SocketConnection(_logger, this, socket, address);
-            socketConnection.UnhandledMessage += HandleUnhandledMessage;
-            foreach (var kvp in genericHandlers)
-            {
-                var handler = SocketSubscription.CreateForIdentifier(ExchangeHelpers.NextId(), kvp.Key, false, false, kvp.Value);
-                socketConnection.AddSubscription(handler);
-            }
-
-            return new CallResult<SocketConnection>(socketConnection);
-        }
-
-        /// <summary>
-        /// Process an unhandled message
-        /// </summary>
-        /// <param name="token">The token that wasn't processed</param>
-        protected virtual void HandleUnhandledMessage(JToken token)
-        {
-        }
-
-        /// <summary>
-        /// Connect a socket
-        /// </summary>
-        /// <param name="socketConnection">The socket to connect</param>
-        /// <returns></returns>
-        protected virtual async Task<CallResult<bool>> ConnectSocketAsync(SocketConnection socketConnection)
-        {
-            if (await socketConnection.ConnectAsync().ConfigureAwait(false))
-            {
-                socketConnections.TryAdd(socketConnection.SocketId, socketConnection);
-                return new CallResult<bool>(true);
-            }
-
-            socketConnection.Dispose();
-            return new CallResult<bool>(new CantConnectError());
-        }
-
-        /// <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.AutoReconnect)
-            {
-                DataInterpreterBytes = dataInterpreterBytes,
-                DataInterpreterString = dataInterpreterString,
-                KeepAliveInterval = KeepAliveInterval,
-                ReconnectInterval = ClientOptions.ReconnectInterval,
-                RateLimiters = RateLimiters,
-                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.Log(LogLevel.Debug, $"Socket {socket.Id} new socket created for " + address);
-            return socket;
-        }
-
-        /// <summary>
-        /// Periodically sends data over a socket connection
-        /// </summary>
-        /// <param name="identifier">Identifier for the periodic send</param>
-        /// <param name="interval">How often</param>
-        /// <param name="objGetter">Method returning the object to send</param>
-        public virtual void SendPeriodic(string identifier, TimeSpan interval, Func<SocketConnection, object> objGetter)
-        {
-            if (objGetter == null)
-                throw new ArgumentNullException(nameof(objGetter));
-
-            periodicEvent = new AsyncResetEvent();
-            periodicTask = Task.Run(async () =>
-            {
-                while (!_disposing)
-                {
-                    await periodicEvent.WaitAsync(interval).ConfigureAwait(false);
-                    if (_disposing)
-                        break;
-
-                    foreach (var socketConnection in socketConnections.Values)
-                    {
-                        if (_disposing)
-                            break;
-
-                        if (!socketConnection.Connected)
-                            continue;
-
-                        var obj = objGetter(socketConnection);
-                        if (obj == null)
-                            continue;
-
-                        _logger.Log(LogLevel.Trace, $"Socket {socketConnection.SocketId} sending periodic {identifier}");
-
-                        try
-                        {
-                            socketConnection.Send(ExchangeHelpers.NextId(), obj, 1);
-                        }
-                        catch (Exception ex)
-                        {
-                            _logger.Log(LogLevel.Warning, $"Socket {socketConnection.SocketId} Periodic send {identifier} failed: " + ex.ToLogString());
-                        }
-                    }
-                }
-            });
-        }
-
-        /// <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)
-        {
-            SocketSubscription? 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.Log(LogLevel.Information, $"Socket {connection.SocketId} Unsubscribing subscription " + 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.Log(LogLevel.Information, $"Socket {subscription.SocketId} Unsubscribing subscription  " + 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.SubscriptionCount);
-            if (sum == 0)
-                return;
-
-            _logger.Log(LogLevel.Information, $"Unsubscribing all {socketConnections.Sum(s => s.Value.SubscriptionCount)} subscriptions");
-            var tasks = new List<Task>();
-            {
-                var socketList = socketConnections.Values;
-                foreach (var sub in socketList)
-                    tasks.Add(sub.CloseAsync()); 
-            }
-
-            await Task.WhenAll(tasks.ToArray()).ConfigureAwait(false);
-        }
-
-        /// <summary>
-        /// Reconnect all connections
-        /// </summary>
-        /// <returns></returns>
-        public virtual async Task ReconnectAsync()
-        {
-            _logger.Log(LogLevel.Information, $"Reconnecting all {socketConnections.Count} connections");
-            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);
-        }
-
-        /// <summary>
-        /// Log the current state of connections and subscriptions
-        /// </summary>
-        public string GetSubscriptionsState()
-        {
-            var sb = new StringBuilder();
-            sb.AppendLine($"{socketConnections.Count} connections, {CurrentSubscriptions} subscriptions, kbps: {IncomingKbps}");
-            foreach (var connection in socketConnections)
-            {
-                sb.AppendLine($"  Connection {connection.Key}: {connection.Value.SubscriptionCount} subscriptions, status: {connection.Value.Status}, authenticated: {connection.Value.Authenticated}, kbps: {connection.Value.IncomingKbps}");
-                foreach (var subscription in connection.Value.Subscriptions)
-                    sb.AppendLine($"    Subscription {subscription.Id}, authenticated: {subscription.Authenticated}, confirmed: {subscription.Confirmed}");
-            }
-            return sb.ToString();
-        }
-
-        /// <summary>
-        /// Dispose the client
-        /// </summary>
-        public override void Dispose()
-        {
-            _disposing = true;
-            periodicEvent?.Set();
-            periodicEvent?.Dispose();
-            if (socketConnections.Sum(s => s.Value.SubscriptionCount) > 0)
-            {
-                _logger.Log(LogLevel.Debug, "Disposing socket client, closing all subscriptions");
-                _ = UnsubscribeAllAsync();
-            }
-            semaphoreSlim?.Dispose();
-            base.Dispose();
         }
     }
 }

CryptoExchange.Net/Converters/ArrayConverter.cs

@@ -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<(Type, Type), Attribute> _attributeByTypeAndTypeCache = new ConcurrentDictionary<(Type, 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>();
 
         /// <inheritdoc />
         public override bool CanConvert(Type objectType)
@@ -28,9 +28,6 @@ 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);
 
@@ -100,30 +97,18 @@ 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 (token.Type == JTokenType.Float)
-                            value = token.Value<decimal>();
-                    }
-
-                    if (value is decimal)
-                    {
-                        property.SetValue(result, value);
-                    }
-                    else if ((property.PropertyType == typeof(decimal)
+                    if ((property.PropertyType == typeof(decimal)
                      || property.PropertyType == typeof(decimal?))
-                     && (value != null && value.ToString().IndexOf("e", StringComparison.OrdinalIgnoreCase) >= 0))
+                     && (value != null && value.ToString().Contains("e")))
                     {
-                        var v = value.ToString();
-                        if (decimal.TryParse(v, NumberStyles.Float, CultureInfo.InvariantCulture, out var dec))
+                        if (decimal.TryParse(value.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out var dec))
                             property.SetValue(result, dec);
                     }
                     else
@@ -187,10 +172,10 @@ 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>

CryptoExchange.Net/Converters/BaseConverter.cs

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

CryptoExchange.Net/Converters/BoolConverter.cs

@@ -1,68 +0,0 @@
-using System;
-using Newtonsoft.Json;
-
-namespace CryptoExchange.Net.Converters
-{
-    /// <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)
-        {
-            switch (reader.Value?.ToString().ToLower().Trim())
-            {
-                case "true":
-                case "yes":
-                case "y":
-                case "1":
-                    return true;
-                case "false":
-                case "no":
-                case "n":
-                case "0":
-                    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/DateTimeConverter.cs

@@ -12,9 +12,9 @@ namespace CryptoExchange.Net.Converters
     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;
+        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)
@@ -134,7 +134,7 @@ namespace CryptoExchange.Net.Converters
         /// </summary>
         /// <param name="seconds"></param>
         /// <returns></returns>
-        public static DateTime ConvertFromSeconds(double seconds) => _epoch.AddTicks((long)Math.Round(seconds * _ticksPerSecond));
+        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>
@@ -146,13 +146,13 @@ namespace CryptoExchange.Net.Converters
         /// </summary>
         /// <param name="microseconds"></param>
         /// <returns></returns>
-        public static DateTime ConvertFromMicroseconds(long microseconds) => _epoch.AddTicks((long)Math.Round(microseconds * _ticksPerMicrosecond));
+        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));
+        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>
@@ -173,14 +173,14 @@ namespace CryptoExchange.Net.Converters
         /// <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);
+        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);
+        public static long? ConvertToNanoseconds(DateTime? time) => time == null ? null : (long)Math.Round((time.Value - _epoch).Ticks / ticksPerNanosecond);
 
 
         /// <inheritdoc />

CryptoExchange.Net/Converters/EnumConverter.cs

@@ -14,20 +14,6 @@ namespace CryptoExchange.Net.Converters
     /// </summary>
     public class EnumConverter : JsonConverter
     {
-        private bool _warnOnMissingEntry = true;
-
-        /// <summary>
-        /// </summary>
-        public EnumConverter() { }
-
-        /// <summary>
-        /// </summary>
-        /// <param name="warnOnMissingEntry"></param>
-        public EnumConverter(bool warnOnMissingEntry)
-        {
-            _warnOnMissingEntry = warnOnMissingEntry;
-        }   
-
         private static readonly ConcurrentDictionary<Type, List<KeyValuePair<object, string>>> _mapping = new();
 
         /// <inheritdoc />
@@ -65,12 +51,8 @@ namespace CryptoExchange.Net.Converters
                         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");
-                }
-            
+                    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;
             }
 
@@ -135,32 +117,22 @@ namespace CryptoExchange.Net.Converters
         /// <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)
+        public static string? GetString<T>(T enumValue)
         {
+            var objectType = typeof(T);
             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());
+            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
-            {
-                var stringValue = GetString(value.GetType(), value);
-                writer.WriteValue(stringValue);
-            }
+            var stringValue = GetString(value);
+            writer.WriteRawValue(stringValue);
         }
     }
 }

CryptoExchange.Net/CryptoExchange.Net.csproj

@@ -6,18 +6,18 @@
     <PackageId>CryptoExchange.Net</PackageId>
     <Authors>JKorf</Authors>
     <Description>A base package for implementing cryptocurrency API's</Description>
-    <PackageVersion>6.1.4</PackageVersion>
-    <AssemblyVersion>6.1.4</AssemblyVersion>
-    <FileVersion>6.1.4</FileVersion>
+    <PackageVersion>5.2.0</PackageVersion>
+    <AssemblyVersion>5.2.0</AssemblyVersion>
+    <FileVersion>5.2.0</FileVersion>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <RepositoryType>git</RepositoryType>
     <RepositoryUrl>https://github.com/JKorf/CryptoExchange.Net.git</RepositoryUrl>
     <PackageProjectUrl>https://github.com/JKorf/CryptoExchange.Net</PackageProjectUrl>
     <NeutralLanguage>en</NeutralLanguage>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-    <PackageReleaseNotes>6.1.4 - Added BoolConverter, Added parameter for logging warning message on missing enum entry to EnumConverter</PackageReleaseNotes>
+    <PackageReleaseNotes>5.2.0 - Refactored websocket code, removed some clutter and simplified, Added ReconnectAsync and GetSubscriptionsState methods on socket clients</PackageReleaseNotes>
     <Nullable>enable</Nullable>
-    <LangVersion>10.0</LangVersion>
+    <LangVersion>9.0</LangVersion>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
   </PropertyGroup>
   <PropertyGroup Label="Deterministic Build" Condition="'$(Configuration)' == 'Release'">
@@ -45,11 +45,10 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.Extensions.Http" Version="3.1.32" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="3.1.32" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="3.1.32" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="[3.1.0,)" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="[3.1.0,)" />
   </ItemGroup>
 </Project>

CryptoExchange.Net/ExchangeHelpers.cs

@@ -8,15 +8,6 @@ namespace CryptoExchange.Net
     /// </summary>
     public static class ExchangeHelpers
     {
-        /// <summary>
-        /// The last used id, use NextId() to get the next id and up this
-        /// </summary>
-        private static int _lastId;
-        /// <summary>
-        /// Lock for id generating
-        /// </summary>
-        private static object _idLock = new();
-
         /// <summary>
         /// Clamp a value between a min and max
         /// </summary>
@@ -52,9 +43,7 @@ namespace CryptoExchange.Net
 
             var offset = value % step.Value;
             if(roundingType == RoundingType.Down)
-            {
                 value -= offset;
-            }
             else
             {
                 if (offset < step / 2)
@@ -127,18 +116,5 @@ 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()
-        {
-            lock (_idLock)
-            {
-                _lastId += 1;
-                return _lastId;
-            }
-        }
     }
 }

CryptoExchange.Net/ExtensionMethods.cs

@@ -6,6 +6,7 @@ using System.Runtime.InteropServices;
 using System.Security;
 using System.Text;
 using System.Web;
+using CryptoExchange.Net.Logging;
 using CryptoExchange.Net.Objects;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
@@ -89,6 +90,31 @@ namespace CryptoExchange.Net
                 parameters.Add(key, JsonConvert.SerializeObject(value, converter));
         }
 
+        /// <summary>
+        /// Add an optional parameter. Not added if value is null
+        /// </summary>
+        /// <param name="parameters"></param>
+        /// <param name="key"></param>
+        /// <param name="value"></param>
+        public static void AddOptionalParameter(this Dictionary<string, string> parameters, string key, string? value)
+        {
+            if (value != null)
+                parameters.Add(key, value);
+        }
+
+        /// <summary>
+        /// Add an optional parameter. Not added if value is null
+        /// </summary>
+        /// <param name="parameters"></param>
+        /// <param name="key"></param>
+        /// <param name="value"></param>
+        /// <param name="converter"></param>
+        public static void AddOptionalParameter(this Dictionary<string, string> parameters, string key, string? value, JsonConverter converter)
+        {
+            if (value != null)
+                parameters.Add(key, JsonConvert.SerializeObject(value, converter));
+        }
+
         /// <summary>
         /// Create a query string of the specified parameters
         /// </summary>
@@ -103,9 +129,7 @@ namespace CryptoExchange.Net
             foreach (var arrayEntry in arraysParameters)
             {
                 if (serializationType == ArrayParametersSerialization.Array)
-                {
                     uriString += $"{string.Join("&", ((object[])(urlEncodeValues ? Uri.EscapeDataString(arrayEntry.Value.ToString()) : arrayEntry.Value)).Select(v => $"{arrayEntry.Key}[]={v}"))}&";
-                }
                 else
                 {
                     var array = (Array)arrayEntry.Value;
@@ -136,9 +160,7 @@ namespace CryptoExchange.Net
                         formData.Add(kvp.Key, value.ToString());
                 }
                 else
-                {
                     formData.Add(kvp.Key, kvp.Value.ToString());
-                }
             }
             return formData.ToString();
         }
@@ -202,11 +224,7 @@ namespace CryptoExchange.Net
                         if (b1 != b2) return false;
                     }
                 }
-                else
-                {
-                    return false;
-                }
-
+                else return false;
                 return true;
             }
             finally
@@ -234,9 +252,9 @@ namespace CryptoExchange.Net
         /// String to JToken
         /// </summary>
         /// <param name="stringData"></param>
-        /// <param name="logger"></param>
+        /// <param name="log"></param>
         /// <returns></returns>
-        public static JToken? ToJToken(this string stringData, ILogger? logger = null)
+        public static JToken? ToJToken(this string stringData, Log? log = null)
         {
             if (string.IsNullOrEmpty(stringData))
                 return null;
@@ -248,15 +266,15 @@ namespace CryptoExchange.Net
             catch (JsonReaderException jre)
             {
                 var info = $"Deserialize JsonReaderException: {jre.Message}, Path: {jre.Path}, LineNumber: {jre.LineNumber}, LinePosition: {jre.LinePosition}. Data: {stringData}";
-                logger?.Log(LogLevel.Error, info);
-                if (logger == null) Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | {info}");
+                log?.Write(LogLevel.Error, info);
+                if (log == null) Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | {info}");
                 return null;
             }
             catch (JsonSerializationException jse)
             {
                 var info = $"Deserialize JsonSerializationException: {jse.Message}. Data: {stringData}";
-                logger?.Log(LogLevel.Error, info);
-                if (logger == null) Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | {info}");
+                log?.Write(LogLevel.Error, info);
+                if (log == null) Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | {info}");
                 return null;
             }
         }
@@ -270,10 +288,8 @@ namespace CryptoExchange.Net
         public static void ValidateIntValues(this int value, string argumentName, params int[] allowedValues)
         {
             if (!allowedValues.Contains(value))
-            {
                 throw new ArgumentException(
                     $"{value} not allowed for parameter {argumentName}, allowed values: {string.Join(", ", allowedValues)}", argumentName);
-            }
         }
 
         /// <summary>
@@ -286,10 +302,8 @@ namespace CryptoExchange.Net
         public static void ValidateIntBetween(this int value, string argumentName, int minValue, int maxValue)
         {
             if (value < minValue || value > maxValue)
-            {
                 throw new ArgumentException(
                     $"{value} not allowed for parameter {argumentName}, min: {minValue}, max: {maxValue}", argumentName);
-            }
         }
 
         /// <summary>
@@ -423,9 +437,7 @@ namespace CryptoExchange.Net
                         httpValueCollection.Add(arraySerialization == ArrayParametersSerialization.Array ? parameter.Key + "[]" : parameter.Key, item.ToString());
                 }
                 else
-                {
                     httpValueCollection.Add(parameter.Key, parameter.Value.ToString());
-                }
             }
             uriBuilder.Query = httpValueCollection.ToString();
             return uriBuilder.Uri;
@@ -454,14 +466,13 @@ namespace CryptoExchange.Net
                         httpValueCollection.Add(arraySerialization == ArrayParametersSerialization.Array ? parameter.Key + "[]" : parameter.Key, item.ToString());
                 }
                 else
-                {
                     httpValueCollection.Add(parameter.Key, parameter.Value.ToString());
-                }
             }
             uriBuilder.Query = httpValueCollection.ToString();
             return uriBuilder.Uri;
         }
 
+
         /// <summary>
         /// Add parameter to URI
         /// </summary>

CryptoExchange.Net/Interfaces/IBaseApiClient.cs

@@ -1,22 +0,0 @@
-using CryptoExchange.Net.Authentication;
-
-namespace CryptoExchange.Net.Interfaces
-{
-    /// <summary>
-    /// Base api client
-    /// </summary>
-    public interface IBaseApiClient
-    {
-        /// <summary>
-        /// Base address
-        /// </summary>
-        string BaseAddress { get; }
-
-        /// <summary>
-        /// Set the API credentials for this API client
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="credentials"></param>
-        void SetApiCredentials<T>(T credentials) where T : ApiCredentials;
-    }
-}

CryptoExchange.Net/Interfaces/IRateLimiter.cs

@@ -1,5 +1,5 @@
+using CryptoExchange.Net.Logging;
 using CryptoExchange.Net.Objects;
-using Microsoft.Extensions.Logging;
 using System.Net.Http;
 using System.Security;
 using System.Threading;
@@ -24,6 +24,6 @@ namespace CryptoExchange.Net.Interfaces
         /// <param name="requestWeight">The weight of the request</param>
         /// <param name="ct">Cancellation token to cancel waiting</param>
         /// <returns>The time in milliseconds spend waiting</returns>
-        Task<CallResult<int>> LimitRequestAsync(ILogger log, string endpoint, HttpMethod method, bool signed, SecureString? apiKey, RateLimitingBehaviour limitBehaviour, int requestWeight, CancellationToken ct);
+        Task<CallResult<int>> LimitRequestAsync(Log log, string endpoint, HttpMethod method, bool signed, SecureString? apiKey, RateLimitingBehaviour limitBehaviour, int requestWeight, CancellationToken ct);
     }
 }

CryptoExchange.Net/Interfaces/IRequestFactory.cs

@@ -1,5 +1,4 @@
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
 using System;
 using System.Net.Http;
 
@@ -23,8 +22,8 @@ namespace CryptoExchange.Net.Interfaces
         /// Configure the requests created by this factory
         /// </summary>
         /// <param name="requestTimeout">Request timeout to use</param>
+        /// <param name="proxy">Proxy settings to use</param>       
         /// <param name="httpClient">Optional shared http client instance</param>
-        /// <param name="proxy">Optional proxy to use when no http client is provided</param>
-        void Configure(ApiProxy? proxy, TimeSpan requestTimeout, HttpClient? httpClient=null);
+        void Configure(TimeSpan requestTimeout, ApiProxy? proxy, HttpClient? httpClient=null);
     }
 }

CryptoExchange.Net/Interfaces/IResponse.cs

@@ -20,11 +20,6 @@ namespace CryptoExchange.Net.Interfaces
         /// </summary>
         bool IsSuccessStatusCode { get; }
 
-        /// <summary>
-        /// The length of the response in bytes
-        /// </summary>
-        long? ContentLength { get; }
-
         /// <summary>
         /// The response headers
         /// </summary>

CryptoExchange.Net/Interfaces/IRestApiClient.cs

@@ -1,33 +0,0 @@
-using CryptoExchange.Net.Objects;
-using System;
-
-namespace CryptoExchange.Net.Interfaces
-{
-    /// <summary>
-    /// Base rest API client
-    /// </summary>
-    public interface IRestApiClient : IBaseApiClient
-    {
-        /// <summary>
-        /// The factory for creating requests. Used for unit testing
-        /// </summary>
-        IRequestFactory RequestFactory { get; set; }
-
-        /// <summary>
-        /// Total amount of requests made with this API client
-        /// </summary>
-        int TotalRequestsMade { get; set; }
-
-        /// <summary>
-        /// Get time offset for an API client. Return null if time syncing shouldnt/cant be done
-        /// </summary>
-        /// <returns></returns>
-        TimeSpan? GetTimeOffset();
-
-        /// <summary>
-        /// Get time sync info for an API client. Return null if time syncing shouldnt/cant be done
-        /// </summary>
-        /// <returns></returns>
-        TimeSyncInfo? GetTimeSyncInfo();
-    }
-}

CryptoExchange.Net/Interfaces/IRestClient.cs

@@ -1,7 +1,6 @@
 using System;
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
 
 namespace CryptoExchange.Net.Interfaces
 {
@@ -11,13 +10,24 @@ namespace CryptoExchange.Net.Interfaces
     public interface IRestClient: IDisposable
     {
         /// <summary>
-        /// The options provided for this client
+        /// The factory for creating requests. Used for unit testing
         /// </summary>
-        ExchangeOptions ClientOptions { get; }
+        IRequestFactory RequestFactory { get; set; }
 
         /// <summary>
         /// The total amount of requests made with this client
         /// </summary>
         int TotalRequestsMade { get; }
+
+        /// <summary>
+        /// The options provided for this client
+        /// </summary>
+        BaseRestClientOptions ClientOptions { get; }
+
+        /// <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>
+        void SetApiCredentials(ApiCredentials credentials);
     }
 }

CryptoExchange.Net/Interfaces/ISocketApiClient.cs

@@ -1,78 +0,0 @@
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
-using CryptoExchange.Net.Sockets;
-using System;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.Interfaces
-{
-    /// <summary>
-    /// Socket API client
-    /// </summary>
-    public interface ISocketApiClient: IBaseApiClient
-    {
-        /// <summary>
-        /// The current amount of socket connections on the API client
-        /// </summary>
-        int CurrentConnections { get; }
-        /// <summary>
-        /// The current amount of subscriptions over all connections
-        /// </summary>
-        int CurrentSubscriptions { get; }
-        /// <summary>
-        /// Incoming data kpbs
-        /// </summary>
-        double IncomingKbps { get; }
-        /// <summary>
-        /// The factory for creating sockets. Used for unit testing
-        /// </summary>
-        IWebsocketFactory SocketFactory { get; set; }
-
-        /// <summary>
-        /// Get the url to reconnect to after losing a connection
-        /// </summary>
-        /// <param name="connection"></param>
-        /// <returns></returns>
-        Task<Uri?> GetReconnectUriAsync(SocketConnection connection);
-
-        /// <summary>
-        /// Log the current state of connections and subscriptions
-        /// </summary>
-        string GetSubscriptionsState();
-        /// <summary>
-        /// Reconnect all connections
-        /// </summary>
-        /// <returns></returns>
-        Task ReconnectAsync();
-        /// <summary>
-        /// Update the original request to send when the connection is restored after disconnecting. Can be used to update an authentication token for example.
-        /// </summary>
-        /// <param name="request">The original request</param>
-        /// <returns></returns>
-        Task<CallResult<object>> RevitalizeRequestAsync(object request);
-        /// <summary>
-        /// Periodically sends data over a socket connection
-        /// </summary>
-        /// <param name="identifier">Identifier for the periodic send</param>
-        /// <param name="interval">How often</param>
-        /// <param name="objGetter">Method returning the object to send</param>
-        void SendPeriodic(string identifier, TimeSpan interval, Func<SocketConnection, object> objGetter);
-        /// <summary>
-        /// Unsubscribe all subscriptions
-        /// </summary>
-        /// <returns></returns>
-        Task UnsubscribeAllAsync();
-        /// <summary>
-        /// Unsubscribe an update subscription
-        /// </summary>
-        /// <param name="subscriptionId">The id of the subscription to unsubscribe</param>
-        /// <returns></returns>
-        Task<bool> UnsubscribeAsync(int subscriptionId);
-        /// <summary>
-        /// Unsubscribe an update subscription
-        /// </summary>
-        /// <param name="subscription">The subscription to unsubscribe</param>
-        /// <returns></returns>
-        Task UnsubscribeAsync(UpdateSubscription subscription);
-    }
-}

CryptoExchange.Net/Interfaces/ISocketClient.cs

@@ -2,7 +2,6 @@
 using System.Threading.Tasks;
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.Sockets;
 
 namespace CryptoExchange.Net.Interfaces
@@ -15,7 +14,13 @@ namespace CryptoExchange.Net.Interfaces
         /// <summary>
         /// The options provided for this client
         /// </summary>
-        ExchangeOptions ClientOptions { get; }
+        BaseSocketClientOptions ClientOptions { get; }
+
+        /// <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>
+        void SetApiCredentials(ApiCredentials credentials);
 
         /// <summary>
         /// Incoming kilobytes per second of data

CryptoExchange.Net/Interfaces/ISymbolOrderBook.cs

@@ -101,22 +101,13 @@ namespace CryptoExchange.Net.Interfaces
 
         /// <summary>
         /// Get the average price that a market order would fill at at the current order book state. This is no guarentee that an order of that quantity would actually be filled
-        /// at that price since between this calculation and the order placement the book might have changed.
+        /// at that price since between this calculation and the order placement the book can have changed.
         /// </summary>
         /// <param name="quantity">The quantity in base asset to fill</param>
         /// <param name="type">The type</param>
         /// <returns>Average fill price</returns>
         CallResult<decimal> CalculateAverageFillPrice(decimal quantity, OrderBookEntryType type);
 
-        /// <summary>
-        /// Get the amount of base asset which can be traded with the quote quantity when placing a market order at at the current order book state. 
-        /// This is no guarentee that an order of that quantity would actually be fill the quantity returned by this since between this calculation and the order placement the book might have changed.
-        /// </summary>
-        /// <param name="quoteQuantity">The quantity in quote asset looking to trade</param>
-        /// <param name="type">The type</param>
-        /// <returns>Amount of base asset tradable with the specified amount of quote asset</returns>
-        CallResult<decimal> CalculateTradableAmount(decimal quoteQuantity, OrderBookEntryType type);
-
         /// <summary>
         /// String representation of the top x entries
         /// </summary>

CryptoExchange.Net/Interfaces/IWebsocket.cs

@@ -1,5 +1,4 @@
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Sockets;
 using System;
 using System.Security.Authentication;
 using System.Text;
@@ -8,7 +7,7 @@ using System.Threading.Tasks;
 namespace CryptoExchange.Net.Interfaces
 {
     /// <summary>
-    /// Websocket connection interface
+    /// Webscoket connection interface
     /// </summary>
     public interface IWebsocket: IDisposable
     {
@@ -21,10 +20,6 @@ namespace CryptoExchange.Net.Interfaces
         /// </summary>
         event Action<string> OnMessage;
         /// <summary>
-        /// Websocket sent event, RequestId as parameter
-        /// </summary>
-        event Action<int> OnRequestSent;
-        /// <summary>
         /// Websocket error event
         /// </summary>
         event Action<Exception> OnError;
@@ -40,10 +35,6 @@ namespace CryptoExchange.Net.Interfaces
         /// Websocket has reconnected to the server
         /// </summary>
         event Action OnReconnected;
-        /// <summary>
-        /// Get reconntion url
-        /// </summary>
-        Func<Task<Uri?>>? GetReconnectionUrl { get; set; }
 
         /// <summary>
         /// Unique id for this socket
@@ -73,10 +64,8 @@ namespace CryptoExchange.Net.Interfaces
         /// <summary>
         /// Send data
         /// </summary>
-        /// <param name="id"></param>
         /// <param name="data"></param>
-        /// <param name="weight"></param>
-        void Send(int id, string data, int weight);
+        void Send(string data);
         /// <summary>
         /// Reconnect the socket
         /// </summary>

CryptoExchange.Net/Interfaces/IWebsocketFactory.cs

@@ -1,5 +1,5 @@
-using CryptoExchange.Net.Sockets;
-using Microsoft.Extensions.Logging;
+using CryptoExchange.Net.Logging;
+using CryptoExchange.Net.Sockets;
 
 namespace CryptoExchange.Net.Interfaces
 {
@@ -11,9 +11,9 @@ namespace CryptoExchange.Net.Interfaces
         /// <summary>
         /// Create a websocket for an url
         /// </summary>
-        /// <param name="logger">The logger</param>
+        /// <param name="log">The logger</param>
         /// <param name="parameters">The parameters to use for the connection</param>
         /// <returns></returns>
-        IWebsocket CreateWebsocket(ILogger logger, WebSocketParameters parameters);
+        IWebsocket CreateWebsocket(Log log, WebSocketParameters parameters);
     }
 }

CryptoExchange.Net/Logging/ConsoleLogger.cs

@@ -0,0 +1,24 @@
+using Microsoft.Extensions.Logging;
+using System;
+
+namespace CryptoExchange.Net.Logging
+{
+    /// <summary>
+    /// ILogger implementation for logging to the console
+    /// </summary>
+    public class ConsoleLogger : ILogger
+    {
+        /// <inheritdoc />
+        public IDisposable BeginScope<TState>(TState state) => null!;
+
+        /// <inheritdoc />
+        public bool IsEnabled(LogLevel logLevel) => true;
+
+        /// <inheritdoc />
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+        {
+            var logMessage = $"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | {logLevel} | {formatter(state, exception)}";
+            Console.WriteLine(logMessage);
+        }
+    }
+}

CryptoExchange.Net/Logging/DebugLogger.cs

@@ -0,0 +1,25 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Diagnostics;
+
+namespace CryptoExchange.Net.Logging
+{
+    /// <summary>
+    /// Default log writer, uses Trace.WriteLine
+    /// </summary>
+    public class DebugLogger: ILogger
+    {
+        /// <inheritdoc />
+        public IDisposable BeginScope<TState>(TState state) => null!;
+
+        /// <inheritdoc />
+        public bool IsEnabled(LogLevel logLevel) => true;
+
+        /// <inheritdoc />
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+        {
+            var logMessage = $"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | {logLevel} | {formatter(state, exception)}";
+            Trace.WriteLine(logMessage);
+        }
+    }
+}

CryptoExchange.Net/Logging/Log.cs

@@ -0,0 +1,79 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+
+namespace CryptoExchange.Net.Logging
+{
+    /// <summary>
+    /// Log implementation
+    /// </summary>
+    public class Log
+    {
+        /// <summary>
+        /// List of ILogger implementations to forward the message to
+        /// </summary>
+        private List<ILogger> writers;
+
+        /// <summary>
+        /// The verbosity of the logging, anything more verbose will not be forwarded to the writers
+        /// </summary>
+        public LogLevel? Level { get; set; } = LogLevel.Information;
+
+        /// <summary>
+        /// Client name
+        /// </summary>
+        public string ClientName { get; set; }
+
+        private readonly object _lock = new object();
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="clientName">The name of the client the logging is used in</param>
+        public Log(string clientName)
+        {
+            ClientName = clientName;
+            writers = new List<ILogger>();
+        }
+
+        /// <summary>
+        /// Set the writers
+        /// </summary>
+        /// <param name="textWriters"></param>
+        public void UpdateWriters(List<ILogger> textWriters)
+        {
+            lock (_lock)
+                writers = textWriters;
+        }
+
+        /// <summary>
+        /// Write a log entry
+        /// </summary>
+        /// <param name="logLevel">The verbosity of the message</param>
+        /// <param name="message">The message to log</param>
+        public void Write(LogLevel logLevel, string message)
+        {
+            if (Level != null && (int)logLevel < (int)Level)
+                return;
+
+            var logMessage = $"{ClientName,-10} | {message}";
+            lock (_lock)
+            {
+                foreach (var writer in writers)
+                {
+                    try
+                    {
+                        writer.Log(logLevel, logMessage);
+                    }
+                    catch (Exception e)
+                    {
+                        // Can't write to the logging so where else to output..
+                        Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Failed to write log to writer {writer.GetType()}: " + e.ToLogString());
+                    }
+                }
+            }
+        }
+    }
+}

CryptoExchange.Net/Objects/AsyncAutoResetEvent.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -13,7 +12,7 @@ namespace CryptoExchange.Net.Objects
     public class AsyncResetEvent : IDisposable
     {
         private static readonly Task<bool> _completed = Task.FromResult(true);
-        private Queue<TaskCompletionSource<bool>> _waits = new Queue<TaskCompletionSource<bool>>();
+        private readonly Queue<TaskCompletionSource<bool>> _waits = new Queue<TaskCompletionSource<bool>>();
         private bool _signaled;
         private readonly bool _reset;
 
@@ -50,13 +49,7 @@ namespace CryptoExchange.Net.Objects
                         var cancellationSource = new CancellationTokenSource(timeout.Value);
                         var registration = cancellationSource.Token.Register(() =>
                         {
-                            lock (_waits)
-                            {
-                                tcs.TrySetResult(false);
-
-                                // Not the cleanest but it works
-                                _waits = new Queue<TaskCompletionSource<bool>>(_waits.Where(i => i != tcs));
-                            }
+                            tcs.TrySetResult(false);
                         }, useSynchronizationContext: false);
                     }
 

CryptoExchange.Net/Objects/CallResult.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Net;
 using System.Net.Http;
-using System.Text;
 
 namespace CryptoExchange.Net.Objects
 {
@@ -39,12 +38,6 @@ namespace CryptoExchange.Net.Objects
         {
             return obj?.Success == true;
         }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return Success ? $"Success" : $"Error: {Error}";
-        }
     }
 
     /// <summary>
@@ -135,24 +128,6 @@ namespace CryptoExchange.Net.Objects
             return new CallResult<K>(data, OriginalData, Error);
         }
 
-        /// <summary>
-        /// Copy as a dataless result
-        /// </summary>
-        /// <returns></returns>
-        public CallResult AsDataless()
-        {
-            return new CallResult(null);
-        }
-
-        /// <summary>
-        /// Copy as a dataless result
-        /// </summary>
-        /// <returns></returns>
-        public CallResult AsDatalessError(Error error)
-        {
-            return new CallResult(error);
-        }
-
         /// <summary>
         /// Copy the WebCallResult to a new data type
         /// </summary>
@@ -163,12 +138,6 @@ namespace CryptoExchange.Net.Objects
         {
             return new CallResult<K>(default, OriginalData, error);
         }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return Success ? $"Success" : $"Error: {Error}";
-        }
     }
 
     /// <summary>
@@ -257,12 +226,6 @@ namespace CryptoExchange.Net.Objects
         {
             return new WebCallResult(ResponseStatusCode, ResponseHeaders, ResponseTime, RequestUrl, RequestBody, RequestMethod, RequestHeaders, error);
         }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return (Success ? $"Success" : $"Error: {Error}") + $" in {ResponseTime}";
-        }
     }
 
     /// <summary>
@@ -296,11 +259,6 @@ namespace CryptoExchange.Net.Objects
         /// </summary>
         public HttpStatusCode? ResponseStatusCode { get; set; }
 
-        /// <summary>
-        /// Length in bytes of the response
-        /// </summary>
-        public long? ResponseLength { get; set; }
-
         /// <summary>
         /// The response headers
         /// </summary>
@@ -317,7 +275,6 @@ namespace CryptoExchange.Net.Objects
         /// <param name="code"></param>
         /// <param name="responseHeaders"></param>
         /// <param name="responseTime"></param>
-        /// <param name="responseLength"></param>
         /// <param name="originalData"></param>
         /// <param name="requestUrl"></param>
         /// <param name="requestBody"></param>
@@ -329,7 +286,6 @@ namespace CryptoExchange.Net.Objects
             HttpStatusCode? code,
             IEnumerable<KeyValuePair<string, IEnumerable<string>>>? responseHeaders,
             TimeSpan? responseTime,
-            long? responseLength,
             string? originalData,
             string? requestUrl,
             string? requestBody,
@@ -341,7 +297,6 @@ namespace CryptoExchange.Net.Objects
             ResponseStatusCode = code;
             ResponseHeaders = responseHeaders;
             ResponseTime = responseTime;
-            ResponseLength = responseLength;
 
             RequestUrl = requestUrl;
             RequestBody = requestBody;
@@ -349,28 +304,11 @@ namespace CryptoExchange.Net.Objects
             RequestMethod = requestMethod;
         }
 
-        /// <summary>
-        /// Copy as a dataless result
-        /// </summary>
-        /// <returns></returns>
-        public new WebCallResult AsDataless()
-        {
-            return new WebCallResult(ResponseStatusCode, ResponseHeaders, ResponseTime, RequestUrl, RequestBody, RequestMethod, RequestHeaders, Error);
-        }
-        /// <summary>
-        /// Copy as a dataless result
-        /// </summary>
-        /// <returns></returns>
-        public new WebCallResult AsDatalessError(Error error)
-        {
-            return new WebCallResult(ResponseStatusCode, ResponseHeaders, ResponseTime, RequestUrl, RequestBody, RequestMethod, RequestHeaders, error);
-        }
-
         /// <summary>
         /// Create a new error result
         /// </summary>
         /// <param name="error">The error</param>
-        public WebCallResult(Error? error) : this(null, null, null, null, null, null, null, null, null, default, error) { }
+        public WebCallResult(Error? error) : this(null, null, null, null, null, null, null, null, default, error) { }
 
         /// <summary>
         /// Copy the WebCallResult to a new data type
@@ -380,7 +318,25 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         public new WebCallResult<K> As<K>([AllowNull] K data)
         {
-            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestUrl, RequestBody, RequestMethod, RequestHeaders, data, Error);
+            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, OriginalData, RequestUrl, RequestBody, RequestMethod, RequestHeaders, data, Error);
+        }
+
+        /// <summary>
+        /// Copy as a dataless result
+        /// </summary>
+        /// <returns></returns>
+        public WebCallResult AsDataless()
+        {
+            return new WebCallResult(ResponseStatusCode, ResponseHeaders, ResponseTime, RequestUrl, RequestBody, RequestMethod, RequestHeaders, Error);
+        }
+
+        /// <summary>
+        /// Copy as a dataless result
+        /// </summary>
+        /// <returns></returns>
+        public WebCallResult AsDatalessError(Error error)
+        {
+            return new WebCallResult(ResponseStatusCode, ResponseHeaders, ResponseTime, RequestUrl, RequestBody, RequestMethod, RequestHeaders, error);
         }
 
         /// <summary>
@@ -391,20 +347,7 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         public new WebCallResult<K> AsError<K>(Error error)
         {
-            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestUrl, RequestBody, RequestMethod, RequestHeaders, default, error);
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            var sb = new StringBuilder();
-            sb.Append(Success ? $"Success response" : $"Error response: {Error}");
-            if (ResponseLength != null)
-                sb.Append($", {ResponseLength} bytes");
-            if (ResponseTime != null)
-                sb.Append($" received in {Math.Round(ResponseTime?.TotalMilliseconds ?? 0)}ms");
-
-            return sb.ToString();
+            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, OriginalData, RequestUrl, RequestBody, RequestMethod, RequestHeaders, default, error);
         }
     }
 }

CryptoExchange.Net/Objects/Error.cs

@@ -1,6 +1,4 @@
-using System;
-
-namespace CryptoExchange.Net.Objects
+namespace CryptoExchange.Net.Objects
 {
     /// <summary>
     /// Base class for errors
@@ -41,7 +39,7 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         public override string ToString()
         {
-            return Code != null ? $"{Code}: {Message} {Data}" : $"{Message} {Data}";
+            return $"{Code}: {Message} {Data}";
         }
     }
 
@@ -54,14 +52,6 @@ namespace CryptoExchange.Net.Objects
         /// ctor
         /// </summary>
         public CantConnectError() : base(null, "Can't connect to the server", null) { }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected CantConnectError(int? code, string message, object? data) : base(code, message, data) { }
     }
 
     /// <summary>
@@ -73,20 +63,12 @@ namespace CryptoExchange.Net.Objects
         /// ctor
         /// </summary>
         public NoApiCredentialsError() : base(null, "No credentials provided for private endpoint", null) { }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected NoApiCredentialsError(int? code, string message, object? data) : base(code, message, data) { }
     }
 
     /// <summary>
     /// Error returned by the server
     /// </summary>
-    public class ServerError : Error
+    public class ServerError: Error
     {
         /// <summary>
         /// ctor
@@ -101,15 +83,9 @@ namespace CryptoExchange.Net.Objects
         /// <param name="code"></param>
         /// <param name="message"></param>
         /// <param name="data"></param>
-        public ServerError(int code, string message, object? data = null) : base(code, message, data) { }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected ServerError(int? code, string message, object? data) : base(code, message, data) { }
+        public ServerError(int code, string message, object? data = null) : base(code, message, data)
+        {
+        }
     }
 
     /// <summary>
@@ -131,14 +107,6 @@ namespace CryptoExchange.Net.Objects
         /// <param name="message"></param>
         /// <param name="data"></param>
         public WebError(int code, string message, object? data = null) : base(code, message, data) { }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected WebError(int? code, string message, object? data): base(code, message, data) { }
     }
 
     /// <summary>
@@ -152,14 +120,6 @@ namespace CryptoExchange.Net.Objects
         /// <param name="message">The error message</param>
         /// <param name="data">The data which caused the error</param>
         public DeserializeError(string message, object? data) : base(null, message, data) { }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected DeserializeError(int? code, string message, object? data): base(code, message, data) { }
     }
 
     /// <summary>
@@ -173,14 +133,6 @@ namespace CryptoExchange.Net.Objects
         /// <param name="message">Error message</param>
         /// <param name="data">Error data</param>
         public UnknownError(string message, object? data = null) : base(null, message, data) { }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected UnknownError(int? code, string message, object? data): base(code, message, data) { }
     }
 
     /// <summary>
@@ -193,73 +145,18 @@ namespace CryptoExchange.Net.Objects
         /// </summary>
         /// <param name="message"></param>
         public ArgumentError(string message) : base(null, "Invalid parameter: " + message, null) { }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected ArgumentError(int? code, string message, object? data): base(code, message, data) { }
     }
 
     /// <summary>
-    /// Rate limit exceeded (client side)
+    /// Rate limit exceeded
     /// </summary>
-    public abstract class BaseRateLimitError : Error
-    {
-        /// <summary>
-        /// When the request can be retried
-        /// </summary>
-        public DateTime? RetryAfter { get; set; }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected BaseRateLimitError(int? code, string message, object? data) : base(code, message, data) { }
-    }
-
-    /// <summary>
-    /// Rate limit exceeded (client side)
-    /// </summary>
-    public class ClientRateLimitError : BaseRateLimitError
+    public class RateLimitError: Error
     {
         /// <summary>
         /// ctor
         /// </summary>
         /// <param name="message"></param>
-        public ClientRateLimitError(string message) : base(null, "Client rate limit exceeded: " + message, null) { }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected ClientRateLimitError(int? code, string message, object? data): base(code, message, data) { }
-    }
-
-    /// <summary>
-    /// Rate limit exceeded (server side)
-    /// </summary>
-    public class ServerRateLimitError : BaseRateLimitError
-    {
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="message"></param>
-        public ServerRateLimitError(string message) : base(null, "Server rate limit exceeded: " + message, null) { }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected ServerRateLimitError(int? code, string message, object? data) : base(code, message, data) { }
+        public RateLimitError(string message) : base(null, "Rate limit exceeded: " + message, null) { }
     }
 
     /// <summary>
@@ -271,33 +168,17 @@ namespace CryptoExchange.Net.Objects
         /// ctor
         /// </summary>
         public CancellationRequestedError() : base(null, "Cancellation requested", null) { }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected CancellationRequestedError(int? code, string message, object? data): base(code, message, data) { }
     }
 
     /// <summary>
     /// Invalid operation requested
     /// </summary>
-    public class InvalidOperationError : Error
+    public class InvalidOperationError: Error
     {
         /// <summary>
         /// ctor
         /// </summary>
         /// <param name="message"></param>
         public InvalidOperationError(string message) : base(null, message, null) { }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected InvalidOperationError(int? code, string message, object? data): base(code, message, data) { }
     }
 }

CryptoExchange.Net/Objects/Options.cs

@@ -0,0 +1,361 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Logging;
+using Microsoft.Extensions.Logging;
+
+namespace CryptoExchange.Net.Objects
+{
+    /// <summary>
+    /// Base options, applicable to everything
+    /// </summary>
+    public class BaseOptions
+    {
+        internal event Action? OnLoggingChanged;
+
+        private LogLevel _logLevel = LogLevel.Information;
+        /// <summary>
+        /// The minimum log level to output
+        /// </summary>
+        public LogLevel LogLevel
+        {
+            get => _logLevel;
+            set
+            {
+                _logLevel = value;
+                OnLoggingChanged?.Invoke();
+            }
+        }
+
+        private List<ILogger> _logWriters = new List<ILogger> { new DebugLogger() };
+        /// <summary>
+        /// The log writers
+        /// </summary>
+        public List<ILogger> LogWriters
+        {
+            get => _logWriters;
+            set
+            {
+                _logWriters = value;
+                OnLoggingChanged?.Invoke();
+            }
+        }
+
+        /// <summary>
+        /// If true, the CallResult and DataEvent objects will also include the originally received json data in the OriginalData property
+        /// </summary>
+        public bool OutputOriginalData { get; set; } = false;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public BaseOptions(): this(null)
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="baseOptions">Copy options from these options to the new options</param>
+        public BaseOptions(BaseOptions? baseOptions)
+        {
+            if (baseOptions == null)
+                return;
+
+            LogLevel = baseOptions.LogLevel;
+            LogWriters = baseOptions.LogWriters.ToList();
+            OutputOriginalData = baseOptions.OutputOriginalData;
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"LogLevel: {LogLevel}, Writers: {LogWriters.Count}, OutputOriginalData: {OutputOriginalData}";
+        }
+    }
+
+    /// <summary>
+    /// Client options, for both the socket and rest clients
+    /// </summary>
+    public class BaseClientOptions : BaseOptions
+    {
+        /// <summary>
+        /// Proxy to use when connecting
+        /// </summary>
+        public ApiProxy? Proxy { get; set; }
+
+        /// <summary>
+        /// Api credentials to be used for signing requests to private endpoints. These credentials will be used for each API in the client, unless overriden in the API options 
+        /// </summary>
+        public ApiCredentials? ApiCredentials { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public BaseClientOptions() : this(null)
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="baseOptions">Copy options from these options to the new options</param>
+        public BaseClientOptions(BaseClientOptions? baseOptions) : base(baseOptions)
+        {
+            if (baseOptions == null)
+                return;
+
+            Proxy = baseOptions.Proxy;
+            ApiCredentials = baseOptions.ApiCredentials?.Copy();
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{base.ToString()}, Proxy: {(Proxy == null ? "-" : Proxy.Host)}, Base.ApiCredentials: {(ApiCredentials == null ? "-" : "set")}";
+        }
+    }
+
+    /// <summary>
+    /// Rest client options
+    /// </summary>
+    public class BaseRestClientOptions : BaseClientOptions
+    {
+        /// <summary>
+        /// The time the server has to respond to a request before timing out
+        /// </summary>
+        public TimeSpan RequestTimeout { get; set; } = TimeSpan.FromSeconds(30);
+
+        /// <summary>
+        /// Http client to use. If a HttpClient is provided in this property the RequestTimeout and Proxy options provided in these options will be ignored in requests and should be set on the provided HttpClient instance
+        /// </summary>
+        public HttpClient? HttpClient { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public BaseRestClientOptions(): this(null)
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="baseOptions">Copy options from these options to the new options</param>
+        public BaseRestClientOptions(BaseRestClientOptions? baseOptions): base(baseOptions)
+        {
+            if (baseOptions == null)
+                return;
+
+            HttpClient = baseOptions.HttpClient;
+            RequestTimeout = baseOptions.RequestTimeout;
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{base.ToString()}, RequestTimeout: {RequestTimeout:c}, HttpClient: {(HttpClient == null ? "-" : "set")}";
+        }
+    }
+
+    /// <summary>
+    /// Socket client options
+    /// </summary>
+    public class BaseSocketClientOptions : BaseClientOptions
+    {
+        /// <summary>
+        /// Whether or not the socket should automatically reconnect when losing connection
+        /// </summary>
+        public bool AutoReconnect { get; set; } = true;
+
+        /// <summary>
+        /// Time to wait between reconnect attempts
+        /// </summary>
+        public TimeSpan ReconnectInterval { get; set; } = TimeSpan.FromSeconds(5);
+
+        /// <summary>
+        /// Max number of concurrent resubscription tasks per socket after reconnecting a socket
+        /// </summary>
+        public int MaxConcurrentResubscriptionsPerSocket { get; set; } = 5;
+
+        /// <summary>
+        /// The max time to wait for a response after sending a request on the socket before giving a timeout
+        /// </summary>
+        public TimeSpan SocketResponseTimeout { get; set; } = TimeSpan.FromSeconds(10);
+
+        /// <summary>
+        /// The max time of not receiving any data after which the connection is assumed to be dropped. This can only be used for socket connections where a steady flow of data is expected,
+        /// for example when the server sends intermittent ping requests
+        /// </summary>
+        public TimeSpan SocketNoDataTimeout { get; set; }
+
+        /// <summary>
+        /// The amount of subscriptions that should be made on a single socket connection. Not all API's support multiple subscriptions on a single socket.
+        /// Setting this to a higher number increases subscription speed because not every subscription needs to connect to the server, but having more subscriptions on a 
+        /// single connection will also increase the amount of traffic on that single connection, potentially leading to issues.
+        /// </summary>
+        public int? SocketSubscriptionsCombineTarget { get; set; }
+
+        /// <summary>
+        /// The max amount of connections to make to the server. Can be used for API's which only allow a certain number of connections. Changing this to a high value might cause issues.
+        /// </summary>
+        public int? MaxSocketConnections { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public BaseSocketClientOptions(): this(null)
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="baseOptions">Copy options from these options to the new options</param>
+        public BaseSocketClientOptions(BaseSocketClientOptions? baseOptions): base(baseOptions)
+        {
+            if (baseOptions == null)
+                return;
+
+            AutoReconnect = baseOptions.AutoReconnect;
+            ReconnectInterval = baseOptions.ReconnectInterval;
+            MaxConcurrentResubscriptionsPerSocket = baseOptions.MaxConcurrentResubscriptionsPerSocket;
+            SocketResponseTimeout = baseOptions.SocketResponseTimeout;
+            SocketNoDataTimeout = baseOptions.SocketNoDataTimeout;
+            SocketSubscriptionsCombineTarget = baseOptions.SocketSubscriptionsCombineTarget;
+            MaxSocketConnections = baseOptions.MaxSocketConnections;
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{base.ToString()}, AutoReconnect: {AutoReconnect}, ReconnectInterval: {ReconnectInterval}, MaxConcurrentResubscriptionsPerSocket: {MaxConcurrentResubscriptionsPerSocket}, SocketResponseTimeout: {SocketResponseTimeout:c}, SocketNoDataTimeout: {SocketNoDataTimeout}, SocketSubscriptionsCombineTarget: {SocketSubscriptionsCombineTarget}, MaxSocketConnections: {MaxSocketConnections}";
+        }
+    }
+
+    /// <summary>
+    /// API client options
+    /// </summary>
+    public class ApiClientOptions
+    {
+        /// <summary>
+        /// The base address of the API
+        /// </summary>
+        public string BaseAddress { get; set; }
+
+        /// <summary>
+        /// The api credentials used for signing requests to this API. Overrides API credentials provided in the client options
+        /// </summary>        
+        public ApiCredentials? ApiCredentials { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+#pragma warning disable 8618 // Will always get filled by the implementation
+        public ApiClientOptions()
+        {
+        }
+#pragma warning restore 8618
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="baseAddress">Base address for the API</param>
+        public ApiClientOptions(string baseAddress)
+        {
+            BaseAddress = baseAddress;
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="baseOptions">Copy values for the provided options</param>
+        /// <param name="newValues">Copy values for the provided options</param>
+        public ApiClientOptions(ApiClientOptions baseOptions, ApiClientOptions? newValues)
+        {
+            BaseAddress = newValues?.BaseAddress ?? baseOptions.BaseAddress;
+            ApiCredentials = newValues?.ApiCredentials?.Copy() ?? baseOptions.ApiCredentials?.Copy();
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"Credentials: {(ApiCredentials == null ? "-" : "Set")}, BaseAddress: {BaseAddress}";
+        }
+    }
+    
+    /// <summary>
+    /// Rest API client options
+    /// </summary>
+    public class RestApiClientOptions: ApiClientOptions
+    {
+        /// <summary>
+        /// List of rate limiters to use
+        /// </summary>
+        public List<IRateLimiter> RateLimiters { get; set; } = new List<IRateLimiter>();
+
+        /// <summary>
+        /// What to do when a call would exceed the rate limit
+        /// </summary>
+        public RateLimitingBehaviour RateLimitingBehaviour { get; set; } = RateLimitingBehaviour.Wait;
+
+        /// <summary>
+        /// Whether or not to automatically sync the local time with the server time
+        /// </summary>
+        public bool AutoTimestamp { get; set; }
+
+        /// <summary>
+        /// How often the timestamp adjustment between client and server is recalculated. If you need a very small TimeSpan here you're probably better of syncing your server time more often
+        /// </summary>
+        public TimeSpan TimestampRecalculationInterval { get; set; } = TimeSpan.FromHours(1);
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public RestApiClientOptions()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="baseAddress">Base address for the API</param>
+        public RestApiClientOptions(string baseAddress): base(baseAddress)
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="baseOn">Copy values for the provided options</param>
+        /// <param name="newValues">Copy values for the provided options</param>
+        public RestApiClientOptions(RestApiClientOptions baseOn, RestApiClientOptions? newValues): base(baseOn, newValues)
+        {
+            RateLimitingBehaviour = newValues?.RateLimitingBehaviour ?? baseOn.RateLimitingBehaviour;
+            AutoTimestamp = newValues?.AutoTimestamp ?? baseOn.AutoTimestamp;
+            TimestampRecalculationInterval = newValues?.TimestampRecalculationInterval ?? baseOn.TimestampRecalculationInterval;
+            RateLimiters = newValues?.RateLimiters.ToList() ?? baseOn?.RateLimiters.ToList() ?? new List<IRateLimiter>();
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{base.ToString()}, RateLimiters: {RateLimiters?.Count}, RateLimitBehaviour: {RateLimitingBehaviour}, AutoTimestamp: {AutoTimestamp}, TimestampRecalculationInterval: {TimestampRecalculationInterval}";
+        }
+    }
+
+    /// <summary>
+    /// Base for order book options
+    /// </summary>
+    public class OrderBookOptions : BaseOptions
+    {
+        /// <summary>
+        /// Whether or not checksum validation is enabled. Default is true, disabling will ignore checksum messages.
+        /// </summary>
+        public bool ChecksumValidationEnabled { get; set; } = true;
+    }
+
+}

CryptoExchange.Net/Objects/Options/ApiOptions.cs

@@ -1,20 +0,0 @@
-using CryptoExchange.Net.Authentication;
-
-namespace CryptoExchange.Net.Objects.Options
-{
-    /// <summary>
-    /// Options for API usage
-    /// </summary>
-    public class ApiOptions
-    {
-        /// <summary>
-        /// If true, the CallResult and DataEvent objects will also include the originally received json data in the OriginalData property
-        /// </summary>
-        public bool? OutputOriginalData { get; set; }
-
-        /// <summary>
-        /// The api credentials used for signing requests to this API. Overrides API credentials provided in the client options
-        /// </summary>        
-        public ApiCredentials? ApiCredentials { get; set; }
-    }
-}

CryptoExchange.Net/Objects/Options/ExchangeOptions.cs

@@ -1,37 +0,0 @@
-using CryptoExchange.Net.Authentication;
-using System;
-
-namespace CryptoExchange.Net.Objects.Options
-{
-    /// <summary>
-    /// Exchange options
-    /// </summary>
-    public class ExchangeOptions
-    {
-        /// <summary>
-        /// Proxy settings
-        /// </summary>
-        public ApiProxy? Proxy { get; set; }
-
-        /// <summary>
-        /// If true, the CallResult and DataEvent objects will also include the originally received json data in the OriginalData property
-        /// </summary>
-        public bool OutputOriginalData { get; set; } = false;
-
-        /// <summary>
-        /// The max time a request is allowed to take
-        /// </summary>
-        public TimeSpan RequestTimeout { get; set; } = TimeSpan.FromSeconds(20);
-
-        /// <summary>
-        /// The api credentials used for signing requests to this API.
-        /// </summary>        
-        public ApiCredentials? ApiCredentials { get; set; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"RequestTimeout: {RequestTimeout}, Proxy: {(Proxy == null ? "-" : "set")}, ApiCredentials: {(ApiCredentials == null ? "-" : "set")}";
-        }
-    }
-}

CryptoExchange.Net/Objects/Options/OrderBookOptions.cs

@@ -1,30 +0,0 @@
-namespace CryptoExchange.Net.Objects.Options
-{
-    /// <summary>
-    /// Base for order book options
-    /// </summary>
-    public class OrderBookOptions : ExchangeOptions
-    {
-        /// <summary>
-        /// Whether or not checksum validation is enabled. Default is true, disabling will ignore checksum messages.
-        /// </summary>
-        public bool ChecksumValidationEnabled { get; set; } = true;
-
-        /// <summary>
-        /// Create a copy of this options
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <returns></returns>
-        public T Copy<T>() where T : OrderBookOptions, new()
-        {
-            return new T
-            {
-                ApiCredentials = ApiCredentials?.Copy(),
-                OutputOriginalData = OutputOriginalData,
-                ChecksumValidationEnabled = ChecksumValidationEnabled,
-                Proxy = Proxy,
-                RequestTimeout = RequestTimeout
-            };
-        }
-    }
-}

CryptoExchange.Net/Objects/Options/RestApiOptions.cs

@@ -1,67 +0,0 @@
-using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Interfaces;
-using System;
-using System.Collections.Generic;
-
-namespace CryptoExchange.Net.Objects.Options
-{
-    /// <summary>
-    /// Http api options
-    /// </summary>
-    public class RestApiOptions : ApiOptions
-    {
-        /// <summary>
-        /// List of rate limiters to use
-        /// </summary>
-        public List<IRateLimiter> RateLimiters { get; set; } = new List<IRateLimiter>();
-
-        /// <summary>
-        /// What to do when a call would exceed the rate limit
-        /// </summary>
-        public RateLimitingBehaviour RateLimitingBehaviour { get; set; } = RateLimitingBehaviour.Wait;
-
-        /// <summary>
-        /// Whether or not to automatically sync the local time with the server time
-        /// </summary>
-        public bool? AutoTimestamp { get; set; }
-
-        /// <summary>
-        /// How often the timestamp adjustment between client and server is recalculated. If you need a very small TimeSpan here you're probably better of syncing your server time more often
-        /// </summary>
-        public TimeSpan? TimestampRecalculationInterval { get; set; }
-
-        /// <summary>
-        /// Create a copy of this options
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <returns></returns>
-        public virtual T Copy<T>() where T : RestApiOptions, new()
-        {
-            return new T
-            {
-                ApiCredentials = ApiCredentials?.Copy(),
-                OutputOriginalData = OutputOriginalData,
-                AutoTimestamp = AutoTimestamp,
-                RateLimiters = RateLimiters,
-                RateLimitingBehaviour = RateLimitingBehaviour,
-                TimestampRecalculationInterval = TimestampRecalculationInterval
-            };
-        }
-    }
-
-    /// <summary>
-    /// Http API options
-    /// </summary>
-    /// <typeparam name="TApiCredentials"></typeparam>
-    public class RestApiOptions<TApiCredentials>: RestApiOptions where TApiCredentials: ApiCredentials
-    {
-        /// <summary>
-        /// The api credentials used for signing requests to this API.
-        /// </summary>
-        public new TApiCredentials? ApiCredentials
-        {
-            get => (TApiCredentials?)base.ApiCredentials;
-            set => base.ApiCredentials = value;
-        }
-    }
-}

CryptoExchange.Net/Objects/Options/RestExchangeOptions.cs

@@ -1,83 +0,0 @@
-using CryptoExchange.Net.Authentication;
-using System;
-
-namespace CryptoExchange.Net.Objects.Options
-{
-    /// <summary>
-    /// Options for a rest exchange client
-    /// </summary>
-    public class RestExchangeOptions: ExchangeOptions
-    {
-        /// <summary>
-        /// Whether or not to automatically sync the local time with the server time
-        /// </summary>
-        public bool AutoTimestamp { get; set; }
-
-        /// <summary>
-        /// How often the timestamp adjustment between client and server is recalculated. If you need a very small TimeSpan here you're probably better of syncing your server time more often
-        /// </summary>
-        public TimeSpan TimestampRecalculationInterval { get; set; } = TimeSpan.FromHours(1);
-
-        /// <summary>
-        /// Create a copy of this options
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <returns></returns>
-        public T Copy<T>() where T : RestExchangeOptions, new()
-        {
-            return new T
-            {
-                OutputOriginalData = OutputOriginalData,
-                AutoTimestamp = AutoTimestamp,
-                TimestampRecalculationInterval = TimestampRecalculationInterval,
-                ApiCredentials = ApiCredentials?.Copy(),
-                Proxy = Proxy,
-                RequestTimeout = RequestTimeout
-            };
-        }
-    }
-
-    /// <summary>
-    /// Options for a rest exchange client
-    /// </summary>
-    /// <typeparam name="TEnvironment"></typeparam>
-    public class RestExchangeOptions<TEnvironment> : RestExchangeOptions where TEnvironment : TradeEnvironment
-    {
-        /// <summary>
-        /// Trade environment. Contains info about URL's to use to connect to the API. To swap environment select another environment for
-        /// the exhange's environment list or create a custom environment using either `[Exchange]Environment.CreateCustom()` or `[Exchange]Environment.[Environment]`, for example `KucoinEnvironment.TestNet` or `BinanceEnvironment.Live`
-        /// </summary>
-#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
-        public TEnvironment Environment { get; set; }
-#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
-
-        /// <summary>
-        /// Create a copy of this options
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <returns></returns>
-        public new T Copy<T>() where T : RestExchangeOptions<TEnvironment>, new()
-        {
-            var result = base.Copy<T>();
-            result.Environment = Environment;
-            return result;
-        }
-    }
-
-    /// <summary>
-    /// Options for a rest exchange client
-    /// </summary>
-    /// <typeparam name="TEnvironment"></typeparam>
-    /// <typeparam name="TApiCredentials"></typeparam>
-    public class RestExchangeOptions<TEnvironment, TApiCredentials> : RestExchangeOptions<TEnvironment> where TEnvironment : TradeEnvironment where TApiCredentials : ApiCredentials
-    {
-        /// <summary>
-        /// The api credentials used for signing requests to this API.
-        /// </summary>        
-        public new TApiCredentials? ApiCredentials
-        {
-            get => (TApiCredentials?)base.ApiCredentials;
-            set => base.ApiCredentials = value;
-        }
-    }
-}

CryptoExchange.Net/Objects/Options/SocketApiOptions.cs

@@ -1,62 +0,0 @@
-using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Interfaces;
-using System;
-using System.Collections.Generic;
-
-namespace CryptoExchange.Net.Objects.Options
-{
-    /// <summary>
-    /// Socket api options
-    /// </summary>
-    public class SocketApiOptions : ApiOptions
-    {
-        /// <summary>
-        /// List of rate limiters to use
-        /// </summary>
-        public List<IRateLimiter> RateLimiters { get; set; } = new List<IRateLimiter>();
-
-        /// <summary>
-        /// The max time of not receiving any data after which the connection is assumed to be dropped. This can only be used for socket connections where a steady flow of data is expected,
-        /// for example when the server sends intermittent ping requests
-        /// </summary>
-        public TimeSpan? SocketNoDataTimeout { get; set; }
-
-        /// <summary>
-        /// The max amount of connections to make to the server. Can be used for API's which only allow a certain number of connections. Changing this to a high value might cause issues.
-        /// </summary>
-        public int? MaxSocketConnections { get; set; }
-
-        /// <summary>
-        /// Create a copy of this options
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <returns></returns>
-        public T Copy<T>() where T : SocketApiOptions, new()
-        {
-            return new T
-            {
-                ApiCredentials = ApiCredentials?.Copy(),
-                OutputOriginalData = OutputOriginalData,
-                RateLimiters = RateLimiters,
-                SocketNoDataTimeout = SocketNoDataTimeout,
-                MaxSocketConnections = MaxSocketConnections,
-            };
-        }
-    }
-
-    /// <summary>
-    /// Socket API options
-    /// </summary>
-    /// <typeparam name="TApiCredentials"></typeparam>
-    public class SocketApiOptions<TApiCredentials> : SocketApiOptions where TApiCredentials : ApiCredentials
-    {
-        /// <summary>
-        /// The api credentials used for signing requests to this API.
-        /// </summary>        
-        public new TApiCredentials? ApiCredentials
-        {
-            get => (TApiCredentials?)base.ApiCredentials;
-            set => base.ApiCredentials = value;
-        }
-    }
-}

CryptoExchange.Net/Objects/Options/SocketExchangeOptions.cs

@@ -1,116 +0,0 @@
-using CryptoExchange.Net.Authentication;
-using System;
-
-namespace CryptoExchange.Net.Objects.Options
-{
-    /// <summary>
-    /// Options for a websocket exchange client
-    /// </summary>
-    public class SocketExchangeOptions : ExchangeOptions
-    {
-        /// <summary>
-        /// Whether or not the socket should automatically reconnect when losing connection
-        /// </summary>
-        public bool AutoReconnect { get; set; } = true;
-
-        /// <summary>
-        /// Time to wait between reconnect attempts
-        /// </summary>
-        public TimeSpan ReconnectInterval { get; set; } = TimeSpan.FromSeconds(5);
-
-        /// <summary>
-        /// Max number of concurrent resubscription tasks per socket after reconnecting a socket
-        /// </summary>
-        public int MaxConcurrentResubscriptionsPerSocket { get; set; } = 5;
-
-        /// <summary>
-        /// The max time of not receiving any data after which the connection is assumed to be dropped. This can only be used for socket connections where a steady flow of data is expected,
-        /// for example when the server sends intermittent ping requests
-        /// </summary>
-        public TimeSpan SocketNoDataTimeout { get; set; }
-
-        /// <summary>
-        /// The amount of subscriptions that should be made on a single socket connection. Not all API's support multiple subscriptions on a single socket.
-        /// Setting this to a higher number increases subscription speed because not every subscription needs to connect to the server, but having more subscriptions on a 
-        /// single connection will also increase the amount of traffic on that single connection, potentially leading to issues.
-        /// </summary>
-        public int? SocketSubscriptionsCombineTarget { get; set; }
-
-        /// <summary>
-        /// The max amount of connections to make to the server. Can be used for API's which only allow a certain number of connections. Changing this to a high value might cause issues.
-        /// </summary>
-        public int? MaxSocketConnections { get; set; }
-
-        /// <summary>
-        /// The time to wait after connecting a socket before sending messages. Can be used for API's which will rate limit if you subscribe directly after connecting.
-        /// </summary>
-        public TimeSpan DelayAfterConnect { get; set; } = TimeSpan.Zero;
-
-        /// <summary>
-        /// Create a copy of this options
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <returns></returns>
-        public T Copy<T>() where T : SocketExchangeOptions, new()
-        {
-            return new T
-            {
-                ApiCredentials = ApiCredentials?.Copy(),
-                OutputOriginalData = OutputOriginalData,
-                AutoReconnect = AutoReconnect,
-                DelayAfterConnect = DelayAfterConnect,
-                MaxConcurrentResubscriptionsPerSocket = MaxConcurrentResubscriptionsPerSocket,
-                ReconnectInterval = ReconnectInterval,
-                SocketNoDataTimeout = SocketNoDataTimeout,
-                SocketSubscriptionsCombineTarget = SocketSubscriptionsCombineTarget,
-                MaxSocketConnections = MaxSocketConnections,
-                Proxy = Proxy,
-                RequestTimeout = RequestTimeout
-            };
-        }
-    }
-
-    /// <summary>
-    /// Options for a socket exchange client
-    /// </summary>
-    /// <typeparam name="TEnvironment"></typeparam>
-    public class SocketExchangeOptions<TEnvironment> : SocketExchangeOptions where TEnvironment : TradeEnvironment
-    {
-        /// <summary>
-        /// Trade environment. Contains info about URL's to use to connect to the API. To swap environment select another environment for
-        /// the exhange's environment list or create a custom environment using either `[Exchange]Environment.CreateCustom()` or `[Exchange]Environment.[Environment]`, for example `KucoinEnvironment.TestNet` or `BinanceEnvironment.Live`
-        /// </summary>
-#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
-        public TEnvironment Environment { get; set; }
-#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
-
-        /// <summary>
-        /// Create a copy of this options
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <returns></returns>
-        public new T Copy<T>() where T : SocketExchangeOptions<TEnvironment>, new()
-        {
-            var result = base.Copy<T>();
-            result.Environment = Environment;
-            return result;
-        }
-    }
-
-    /// <summary>
-    /// Options for a socket exchange client
-    /// </summary>
-    /// <typeparam name="TEnvironment"></typeparam>
-    /// <typeparam name="TApiCredentials"></typeparam>
-    public class SocketExchangeOptions<TEnvironment, TApiCredentials> : SocketExchangeOptions<TEnvironment> where TEnvironment : TradeEnvironment where TApiCredentials : ApiCredentials
-    {
-        /// <summary>
-        /// The api credentials used for signing requests to this API.
-        /// </summary>        
-        public new TApiCredentials? ApiCredentials
-        {
-            get => (TApiCredentials?)base.ApiCredentials;
-            set => base.ApiCredentials = value;
-        }
-    }
-}

CryptoExchange.Net/Objects/RateLimiter.cs

@@ -1,4 +1,5 @@
 using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Logging;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
@@ -17,7 +18,7 @@ namespace CryptoExchange.Net.Objects
     public class RateLimiter : IRateLimiter
     {
         private readonly object _limiterLock = new object();
-        internal List<Limiter> _limiters = new List<Limiter>();
+        internal List<Limiter> Limiters = new List<Limiter>();
 
         /// <summary>
         /// Create a new RateLimiter. Configure the rate limiter by calling <see cref="AddTotalRateLimit"/>, 
@@ -35,7 +36,7 @@ namespace CryptoExchange.Net.Objects
         public RateLimiter AddTotalRateLimit(int limit, TimeSpan perTimePeriod)
         {
             lock(_limiterLock)
-                _limiters.Add(new TotalRateLimiter(limit, perTimePeriod, null));
+                Limiters.Add(new TotalRateLimiter(limit, perTimePeriod, null));
             return this;
         }
 
@@ -50,7 +51,7 @@ namespace CryptoExchange.Net.Objects
         public RateLimiter AddEndpointLimit(string endpoint, int limit, TimeSpan perTimePeriod, HttpMethod? method = null, bool excludeFromOtherRateLimits = false)
         {
             lock(_limiterLock)
-                _limiters.Add(new EndpointRateLimiter(new[] { endpoint }, limit, perTimePeriod, method, excludeFromOtherRateLimits));
+                Limiters.Add(new EndpointRateLimiter(new[] { endpoint }, limit, perTimePeriod, method, excludeFromOtherRateLimits));
             return this;
         }
 
@@ -65,7 +66,7 @@ namespace CryptoExchange.Net.Objects
         public RateLimiter AddEndpointLimit(IEnumerable<string> endpoints, int limit, TimeSpan perTimePeriod, HttpMethod? method = null, bool excludeFromOtherRateLimits = false)
         {
             lock(_limiterLock)
-                _limiters.Add(new EndpointRateLimiter(endpoints.ToArray(), limit, perTimePeriod, method, excludeFromOtherRateLimits));
+                Limiters.Add(new EndpointRateLimiter(endpoints.ToArray(), limit, perTimePeriod, method, excludeFromOtherRateLimits));
             return this;
         }
 
@@ -81,7 +82,7 @@ namespace CryptoExchange.Net.Objects
         public RateLimiter AddPartialEndpointLimit(string endpoint, int limit, TimeSpan perTimePeriod, HttpMethod? method = null, bool countPerEndpoint = false, bool ignoreOtherRateLimits = false)
         {
             lock(_limiterLock)
-                _limiters.Add(new PartialEndpointRateLimiter(new[] { endpoint }, limit, perTimePeriod, method, ignoreOtherRateLimits, countPerEndpoint));
+                Limiters.Add(new PartialEndpointRateLimiter(new[] { endpoint }, limit, perTimePeriod, method, ignoreOtherRateLimits, countPerEndpoint));
             return this;
         }
 
@@ -95,46 +96,33 @@ namespace CryptoExchange.Net.Objects
         public RateLimiter AddApiKeyLimit(int limit, TimeSpan perTimePeriod, bool onlyForSignedRequests, bool excludeFromTotalRateLimit)
         {
             lock(_limiterLock)
-                _limiters.Add(new ApiKeyRateLimiter(limit, perTimePeriod, null, onlyForSignedRequests, excludeFromTotalRateLimit));
-            return this;
-        }
-
-        /// <summary>
-        /// Add a rate limit for the amount of messages that can be send per connection
-        /// </summary>
-        /// <param name="endpoint">The endpoint that the limit is for</param>
-        /// <param name="limit">The limit per period. Note that this is weight, not single request, altough by default requests have a weight of 1</param>
-        /// <param name="perTimePeriod">The time period the limit is for</param>
-        public RateLimiter AddConnectionRateLimit(string endpoint, int limit, TimeSpan perTimePeriod)
-        {
-            lock (_limiterLock)
-                _limiters.Add(new ConnectionRateLimiter(new[] { endpoint }, limit, perTimePeriod));
+                Limiters.Add(new ApiKeyRateLimiter(limit, perTimePeriod, null, onlyForSignedRequests, excludeFromTotalRateLimit));
             return this;
         }
 
         /// <inheritdoc />
-        public async Task<CallResult<int>> LimitRequestAsync(ILogger logger, string endpoint, HttpMethod method, bool signed, SecureString? apiKey, RateLimitingBehaviour limitBehaviour, int requestWeight, CancellationToken ct)
+        public async Task<CallResult<int>> LimitRequestAsync(Log log, string endpoint, HttpMethod method, bool signed, SecureString? apiKey, RateLimitingBehaviour limitBehaviour, int requestWeight, CancellationToken ct)
         {
             int totalWaitTime = 0;
 
-            List<EndpointRateLimiter> endpointLimits;
+            EndpointRateLimiter? endpointLimit;
             lock (_limiterLock)
-                endpointLimits = _limiters.OfType<EndpointRateLimiter>().Where(h => h.Endpoints.Contains(endpoint) && (h.Method  == null || h.Method == method)).ToList();
-            foreach (var endpointLimit in endpointLimits)
+                endpointLimit = Limiters.OfType<EndpointRateLimiter>().SingleOrDefault(h => h.Endpoints.Contains(endpoint) && (h.Method  == null || h.Method == method));
+            if(endpointLimit != null)
             {
-                var waitResult = await ProcessTopic(logger, endpointLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
+                var waitResult = await ProcessTopic(log, endpointLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
                 if (!waitResult)
                     return waitResult;
 
                 totalWaitTime += waitResult.Data;
             }
 
-            if (endpointLimits.Any(l => l.IgnoreOtherRateLimits))
+            if (endpointLimit?.IgnoreOtherRateLimits == true)
                 return new CallResult<int>(totalWaitTime);
 
             List<PartialEndpointRateLimiter> partialEndpointLimits;
             lock (_limiterLock)
-                partialEndpointLimits = _limiters.OfType<PartialEndpointRateLimiter>().Where(h => h.PartialEndpoints.Any(h => endpoint.Contains(h)) && (h.Method == null || h.Method == method)).ToList();
+                partialEndpointLimits = Limiters.OfType<PartialEndpointRateLimiter>().Where(h => h.PartialEndpoints.Any(h => endpoint.Contains(h)) && (h.Method == null || h.Method == method)).ToList();
             foreach (var partialEndpointLimit in partialEndpointLimits)
             {
                 if (partialEndpointLimit.CountPerEndpoint)
@@ -142,15 +130,15 @@ namespace CryptoExchange.Net.Objects
                     SingleTopicRateLimiter? thisEndpointLimit;
                     lock (_limiterLock)
                     {
-                        thisEndpointLimit = _limiters.OfType<SingleTopicRateLimiter>().SingleOrDefault(h => h.Type == RateLimitType.PartialEndpoint && (string)h.Topic == endpoint);
+                        thisEndpointLimit = Limiters.OfType<SingleTopicRateLimiter>().SingleOrDefault(h => h.Type == RateLimitType.PartialEndpoint && (string)h.Topic == endpoint);
                         if (thisEndpointLimit == null)
                         {
                             thisEndpointLimit = new SingleTopicRateLimiter(endpoint, partialEndpointLimit);
-                            _limiters.Add(thisEndpointLimit);
+                            Limiters.Add(thisEndpointLimit);
                         }
                     }
 
-                    var waitResult = await ProcessTopic(logger, thisEndpointLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
+                    var waitResult = await ProcessTopic(log, thisEndpointLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
                     if (!waitResult)
                         return waitResult;
 
@@ -158,7 +146,7 @@ namespace CryptoExchange.Net.Objects
                 }
                 else
                 {
-                    var waitResult = await ProcessTopic(logger, partialEndpointLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
+                    var waitResult = await ProcessTopic(log, partialEndpointLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
                     if (!waitResult)
                         return waitResult;
 
@@ -169,16 +157,16 @@ namespace CryptoExchange.Net.Objects
             if(partialEndpointLimits.Any(p => p.IgnoreOtherRateLimits))
                 return new CallResult<int>(totalWaitTime);
 
-            List<ApiKeyRateLimiter> apiLimits;
+            ApiKeyRateLimiter? apiLimit;
             lock (_limiterLock)
-                apiLimits = _limiters.OfType<ApiKeyRateLimiter>().Where(h => h.Type == RateLimitType.ApiKey).ToList();
-            foreach (var apiLimit in apiLimits)
+                apiLimit = Limiters.OfType<ApiKeyRateLimiter>().SingleOrDefault(h => h.Type == RateLimitType.ApiKey);
+            if (apiLimit != null)
             {
                 if(apiKey == null)
                 {
                     if (!apiLimit.OnlyForSignedRequests)
                     {
-                        var waitResult = await ProcessTopic(logger, apiLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
+                        var waitResult = await ProcessTopic(log, apiLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
                         if (!waitResult)
                             return waitResult;
 
@@ -190,15 +178,15 @@ namespace CryptoExchange.Net.Objects
                     SingleTopicRateLimiter? thisApiLimit;
                     lock (_limiterLock)
                     {
-                        thisApiLimit = _limiters.OfType<SingleTopicRateLimiter>().SingleOrDefault(h => h.Type == RateLimitType.ApiKey && ((SecureString)h.Topic).IsEqualTo(apiKey));
+                        thisApiLimit = Limiters.OfType<SingleTopicRateLimiter>().SingleOrDefault(h => h.Type == RateLimitType.ApiKey && ((SecureString)h.Topic).IsEqualTo(apiKey));
                         if (thisApiLimit == null)
                         {
                             thisApiLimit = new SingleTopicRateLimiter(apiKey, apiLimit);
-                            _limiters.Add(thisApiLimit);
+                            Limiters.Add(thisApiLimit);
                         }
                     }
 
-                    var waitResult = await ProcessTopic(logger, thisApiLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
+                    var waitResult = await ProcessTopic(log, thisApiLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
                     if (!waitResult)
                         return waitResult;
 
@@ -206,15 +194,15 @@ namespace CryptoExchange.Net.Objects
                 }
             }
 
-            if ((signed || apiLimits.All(l => !l.OnlyForSignedRequests)) && apiLimits.Any(l => l.IgnoreTotalRateLimit))
+            if ((signed || apiLimit?.OnlyForSignedRequests == false) && apiLimit?.IgnoreTotalRateLimit == true)
                 return new CallResult<int>(totalWaitTime);
 
-            List<TotalRateLimiter> totalLimits;
+            TotalRateLimiter? totalLimit;
             lock (_limiterLock)
-                totalLimits = _limiters.OfType<TotalRateLimiter>().ToList();
-            foreach(var totalLimit in  totalLimits) 
+                totalLimit = Limiters.OfType<TotalRateLimiter>().SingleOrDefault();
+            if (totalLimit != null)
             {
-                var waitResult = await ProcessTopic(logger, totalLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
+                var waitResult = await ProcessTopic(log, totalLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
                 if (!waitResult)
                     return waitResult;
 
@@ -224,7 +212,7 @@ namespace CryptoExchange.Net.Objects
             return new CallResult<int>(totalWaitTime);
         }
 
-        private static async Task<CallResult<int>> ProcessTopic(ILogger logger, Limiter historyTopic, string endpoint, int requestWeight, RateLimitingBehaviour limitBehaviour, CancellationToken ct)
+        private static async Task<CallResult<int>> ProcessTopic(Log log, Limiter historyTopic, string endpoint, int requestWeight, RateLimitingBehaviour limitBehaviour, CancellationToken ct)
         {
             var sw = Stopwatch.StartNew();
             try
@@ -237,68 +225,63 @@ namespace CryptoExchange.Net.Objects
             }
             sw.Stop();
 
-            try
+            int totalWaitTime = 0;
+            while (true)
             {
-                int totalWaitTime = 0;
-                while (true)
+                // Remove requests no longer in time period from the history
+                var checkTime = DateTime.UtcNow;
+                for (var i = 0; i < historyTopic.Entries.Count; i++)
                 {
-                    // Remove requests no longer in time period from the history
-                    var checkTime = DateTime.UtcNow;
-                    for (var i = 0; i < historyTopic.Entries.Count; i++)
+                    if (historyTopic.Entries[i].Timestamp < checkTime - historyTopic.Period)
                     {
-                        if (historyTopic.Entries[i].Timestamp < checkTime - historyTopic.Period)
-                        {
-                            historyTopic.Entries.Remove(historyTopic.Entries[i]);
-                            i--;
-                        }
-                        else
-                            break;
-                    }
-
-                    var currentWeight = !historyTopic.Entries.Any() ? 0 : historyTopic.Entries.Sum(h => h.Weight);
-                    if (currentWeight + requestWeight > historyTopic.Limit)
-                    {
-                        if (currentWeight == 0)
-                            throw new Exception("Request limit reached without any prior request. " +
-                                $"This request can never execute with the current rate limiter. Request weight: {requestWeight}, Ratelimit: {historyTopic.Limit}");
-
-                        // Wait until the next entry should be removed from the history
-                        var thisWaitTime = (int)Math.Round(((historyTopic.Entries.First().Timestamp + historyTopic.Period) - checkTime).TotalMilliseconds);
-                        if (thisWaitTime > 0)
-                        {
-                            if (limitBehaviour == RateLimitingBehaviour.Fail)
-                            {
-                                var msg = $"Request to {endpoint} failed because of rate limit `{historyTopic.Type}`. Current weight: {currentWeight}/{historyTopic.Limit}, request weight: {requestWeight}";
-                                logger.Log(LogLevel.Warning, msg);
-                                return new CallResult<int>(new ClientRateLimitError(msg) { RetryAfter = DateTime.UtcNow.AddSeconds(thisWaitTime) });
-                            }
-
-                            logger.Log(LogLevel.Information, $"Message to {endpoint} waiting {thisWaitTime}ms for rate limit `{historyTopic.Type}`. Current weight: {currentWeight}/{historyTopic.Limit}, request weight: {requestWeight}");
-                            try
-                            {
-                                await Task.Delay(thisWaitTime, ct).ConfigureAwait(false);
-                            }
-                            catch (OperationCanceledException)
-                            {
-                                return new CallResult<int>(new CancellationRequestedError());
-                            }
-                            totalWaitTime += thisWaitTime;
-                        }
+                        historyTopic.Entries.Remove(historyTopic.Entries[i]);
+                        i--;
                     }
                     else
-                    {
                         break;
-                    }
                 }
 
-                var newTime = DateTime.UtcNow;
-                historyTopic.Entries.Add(new LimitEntry(newTime, requestWeight));
-                return new CallResult<int>(totalWaitTime);
-            }
-            finally
-            {
-                historyTopic.Semaphore.Release();
+                var currentWeight = !historyTopic.Entries.Any() ? 0: historyTopic.Entries.Sum(h => h.Weight);
+                if (currentWeight + requestWeight > historyTopic.Limit)
+                {
+                    if (currentWeight == 0)
+                        throw new Exception("Request limit reached without any prior request. " +
+                            $"This request can never execute with the current rate limiter. Request weight: {requestWeight}, Ratelimit: {historyTopic.Limit}");
+
+                    // Wait until the next entry should be removed from the history
+                    var thisWaitTime = (int)Math.Round((historyTopic.Entries.First().Timestamp - (checkTime - historyTopic.Period)).TotalMilliseconds);
+                    if (thisWaitTime > 0)
+                    {
+                        if (limitBehaviour == RateLimitingBehaviour.Fail)
+                        {
+                            historyTopic.Semaphore.Release();
+                            var msg = $"Request to {endpoint} failed because of rate limit `{historyTopic.Type}`. Current weight: {currentWeight}/{historyTopic.Limit}, request weight: {requestWeight}";
+                            log.Write(LogLevel.Warning, msg);
+                            return new CallResult<int>(new RateLimitError(msg));
+                        }
+
+                        log.Write(LogLevel.Information, $"Request to {endpoint} waiting {thisWaitTime}ms for rate limit `{historyTopic.Type}`. Current weight: {currentWeight}/{historyTopic.Limit}, request weight: {requestWeight}");
+                        try
+                        {
+                            await Task.Delay(thisWaitTime, ct).ConfigureAwait(false);
+                        }
+                        catch (OperationCanceledException)
+                        {
+                            return new CallResult<int>(new CancellationRequestedError());
+                        }
+                        totalWaitTime += thisWaitTime;
+                    }
+                }
+                else
+                {
+                    break;
+                }
             }
+
+            var newTime = DateTime.UtcNow;
+            historyTopic.Entries.Add(new LimitEntry(newTime, requestWeight));
+            historyTopic.Semaphore.Release();
+            return new CallResult<int>(totalWaitTime);
         }
 
         internal struct LimitEntry
@@ -347,24 +330,6 @@ namespace CryptoExchange.Net.Objects
             }
         }
 
-        internal class ConnectionRateLimiter : PartialEndpointRateLimiter
-        {
-            public ConnectionRateLimiter(int limit, TimeSpan perPeriod)
-                : base(new[] { "/" }, limit, perPeriod, null, true, true)
-            {
-            }
-
-            public ConnectionRateLimiter(string[] endpoints, int limit, TimeSpan perPeriod)
-                : base(endpoints, limit, perPeriod, null, true, true)
-            {
-            }
-
-            public override string ToString()
-            {
-                return nameof(ConnectionRateLimiter);
-            }
-        }
-
         internal class EndpointRateLimiter: Limiter
         {
             public string[] Endpoints { get; set; }

CryptoExchange.Net/Objects/TimeSyncState.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Threading;
+using CryptoExchange.Net.Logging;
 using Microsoft.Extensions.Logging;
 
 namespace CryptoExchange.Net.Objects
@@ -44,7 +45,7 @@ namespace CryptoExchange.Net.Objects
         /// <summary>
         /// Logger
         /// </summary>
-        public ILogger Logger { get; }
+        public Log Log { get; }
         /// <summary>
         /// Should synchronize time
         /// </summary>
@@ -61,13 +62,13 @@ namespace CryptoExchange.Net.Objects
         /// <summary>
         /// ctor
         /// </summary>
-        /// <param name="logger"></param>
+        /// <param name="log"></param>
         /// <param name="recalculationInterval"></param>
         /// <param name="syncTime"></param>
         /// <param name="syncState"></param>
-        public TimeSyncInfo(ILogger logger, bool syncTime, TimeSpan recalculationInterval, TimeSyncState syncState)
+        public TimeSyncInfo(Log log, bool syncTime, TimeSpan recalculationInterval, TimeSyncState syncState)
         {
-            Logger = logger;
+            Log = log;
             SyncTime = syncTime;
             RecalculationInterval = recalculationInterval;
             TimeSyncState = syncState;
@@ -82,12 +83,12 @@ namespace CryptoExchange.Net.Objects
             TimeSyncState.LastSyncTime = DateTime.UtcNow;
             if (offset.TotalMilliseconds > 0 && offset.TotalMilliseconds < 500)
             {
-                Logger.Log(LogLevel.Information, $"{TimeSyncState.ApiName} Time offset within limits, set offset to 0ms");
+                Log.Write(LogLevel.Information, $"{TimeSyncState.ApiName} Time offset within limits, set offset to 0ms");
                 TimeSyncState.TimeOffset = TimeSpan.Zero;
             }
             else
             {
-                Logger.Log(LogLevel.Information, $"{TimeSyncState.ApiName} Time offset set to {Math.Round(offset.TotalMilliseconds)}ms");
+                Log.Write(LogLevel.Information, $"{TimeSyncState.ApiName} Time offset set to {Math.Round(offset.TotalMilliseconds)}ms");
                 TimeSyncState.TimeOffset = offset;
             }
         }

CryptoExchange.Net/Objects/TraceLogger.cs

@@ -1,63 +0,0 @@
-using Microsoft.Extensions.Logging;
-using System;
-using System.Diagnostics;
-
-namespace CryptoExchange.Net.Objects
-{
-    /// <summary>
-    /// Trace logger provider for creating trace loggers
-    /// </summary>
-    public class TraceLoggerProvider : ILoggerProvider
-    {
-        private readonly LogLevel _logLevel;
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="logLevel"></param>
-        public TraceLoggerProvider(LogLevel? logLevel = null)
-        {
-            _logLevel = logLevel ?? LogLevel.Trace;
-        }
-
-        /// <inheritdoc />
-        public ILogger CreateLogger(string categoryName) => new TraceLogger(categoryName, _logLevel);
-        /// <inheritdoc />
-        public void Dispose() { }
-    }
-
-    /// <summary>
-    /// Trace logger
-    /// </summary>
-    public class TraceLogger : ILogger
-    {
-        private string? _categoryName;
-        private LogLevel _logLevel;
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="categoryName"></param>
-        /// <param name="level"></param>
-        public TraceLogger(string? categoryName = null, LogLevel level = LogLevel.Trace)
-        {
-            _categoryName = categoryName;
-            _logLevel = level;
-        }
-
-        /// <inheritdoc />
-        public IDisposable BeginScope<TState>(TState state) => null!;
-
-        /// <inheritdoc />
-        public bool IsEnabled(LogLevel logLevel) => (int)logLevel < (int)_logLevel;
-        /// <inheritdoc />
-        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
-        {
-            if ((int)logLevel < (int)_logLevel)
-                return;
-
-            var logMessage = $"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | {logLevel} | {(_categoryName == null ? "" : $"{_categoryName} | ")}{formatter(state, exception)}";
-            Trace.WriteLine(logMessage);
-        }
-    }
-}

CryptoExchange.Net/Objects/TradeEnvironment.cs

@@ -1,39 +0,0 @@
-using System.Collections.Generic;
-
-namespace CryptoExchange.Net.Objects
-{
-    /// <summary>
-    /// Trade environment names
-    /// </summary>
-    public static class TradeEnvironmentNames
-    {
-        /// <summary>
-        /// Live environment
-        /// </summary>
-        public const string Live = "live";
-        /// <summary>
-        /// Testnet environment
-        /// </summary>
-        public const string Testnet = "testnet";
-    }
-
-    /// <summary>
-    /// Trade environment. Contains info about URL's to use to connect to the API. To swap environment select another environment for
-    /// the echange's environment list or create a custom environment using either `[Exchange]Environment.CreateCustom()` or `[Exchange]Environment.[Environment]`, for example `KucoinEnvironment.TestNet` or `BinanceEnvironment.Live`
-    /// </summary>
-    public class TradeEnvironment
-    {
-        /// <summary>
-        /// Name of the environment
-        /// </summary>
-        public string EnvironmentName { get; init; }
-
-        /// <summary>
-        /// </summary>
-        /// <param name="name"></param>
-        protected TradeEnvironment(string name)
-        {
-            EnvironmentName = name;
-        }
-    }
-}

CryptoExchange.Net/OrderBook/ProcessBufferEntry.cs

@@ -13,17 +13,14 @@ namespace CryptoExchange.Net.OrderBook
         /// First sequence number in this update
         /// </summary>
         public long FirstUpdateId { get; set; }
-
         /// <summary>
         /// Last sequence number in this update
         /// </summary>
         public long LastUpdateId { get; set; }
-
         /// <summary>
         /// List of changed/new asks
         /// </summary>
         public IEnumerable<ISymbolOrderBookEntry> Asks { get; set; } = Array.Empty<ISymbolOrderBookEntry>();
-
         /// <summary>
         /// List of changed/new bids
         /// </summary>

CryptoExchange.Net/OrderBook/SymbolOrderBook.cs

@@ -7,8 +7,8 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Logging;
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.Sockets;
 using Microsoft.Extensions.Logging;
 
@@ -30,7 +30,7 @@ namespace CryptoExchange.Net.OrderBook
 
         private readonly AsyncResetEvent _queueEvent;
         private readonly ConcurrentQueue<object> _processQueue;
-        private bool _validateChecksum;
+        private readonly bool _validateChecksum;
 
         private class EmptySymbolOrderBookEntry : ISymbolOrderBookEntry
         {
@@ -40,47 +40,48 @@ namespace CryptoExchange.Net.OrderBook
                 set { } }
         }
 
-        private static readonly ISymbolOrderBookEntry _emptySymbolOrderBookEntry = new EmptySymbolOrderBookEntry();
+        private static readonly ISymbolOrderBookEntry emptySymbolOrderBookEntry = new EmptySymbolOrderBookEntry();
+
 
         /// <summary>
         /// A buffer to store messages received before the initial book snapshot is processed. These messages
         /// will be processed after the book snapshot is set. Any messages in this buffer with sequence numbers lower
         /// than the snapshot sequence number will be discarded
         /// </summary>
-        protected readonly List<ProcessBufferRangeSequenceEntry> _processBuffer;
+        protected readonly List<ProcessBufferRangeSequenceEntry> processBuffer;
 
         /// <summary>
         /// The ask list, should only be accessed using the bookLock
         /// </summary>
-        protected SortedList<decimal, ISymbolOrderBookEntry> _asks;
+        protected SortedList<decimal, ISymbolOrderBookEntry> asks;
 
         /// <summary>
         /// The bid list, should only be accessed using the bookLock
         /// </summary>
-        protected SortedList<decimal, ISymbolOrderBookEntry> _bids;
+        protected SortedList<decimal, ISymbolOrderBookEntry> bids;
 
         /// <summary>
         /// The log
         /// </summary>
-        protected ILogger _logger;
+        protected Log log;
 
         /// <summary>
         /// Whether update numbers are consecutive. If set to true and an update comes in which isn't the previous sequences number + 1
         /// the book will resynchronize as it is deemed out of sync
         /// </summary>
-        protected bool _sequencesAreConsecutive;
+        protected bool sequencesAreConsecutive;
         
         /// <summary>
         /// Whether levels should be strictly enforced. For example, when an order book has 25 levels and a new update comes in which pushes
         /// the current level 25 ask out of the top 25, should the curent the level 26 entry be removed from the book or does the 
         /// server handle this
         /// </summary>
-        protected bool _strictLevels;
+        protected bool strictLevels;
 
         /// <summary>
         /// If the initial snapshot of the book has been set
         /// </summary>
-        protected bool _bookSet;
+        protected bool bookSet;
 
         /// <summary>
         /// The amount of levels for this book
@@ -101,7 +102,7 @@ namespace CryptoExchange.Net.OrderBook
 
                 var old = _status;
                 _status = value;
-                _logger.Log(LogLevel.Information, $"{Id} order book {Symbol} status changed: {old} => {value}");
+                log.Write(LogLevel.Information, $"{Id} order book {Symbol} status changed: {old} => {value}");
                 OnStatusChange?.Invoke(old, _status);
             }
         }
@@ -136,7 +137,7 @@ namespace CryptoExchange.Net.OrderBook
             get
             {
                 lock (_bookLock)
-                    return _asks.Select(a => a.Value).ToList();
+                    return asks.Select(a => a.Value).ToList();
             }
         }
 
@@ -146,7 +147,7 @@ namespace CryptoExchange.Net.OrderBook
             get
             {
                 lock (_bookLock)
-                    return _bids.Select(a => a.Value).ToList();
+                    return bids.Select(a => a.Value).ToList();
             }
         }
 
@@ -166,7 +167,7 @@ namespace CryptoExchange.Net.OrderBook
             get
             {
                 lock (_bookLock)
-                    return _bids.FirstOrDefault().Value ?? _emptySymbolOrderBookEntry;
+                    return bids.FirstOrDefault().Value ?? emptySymbolOrderBookEntry;
             }
         }
 
@@ -176,7 +177,7 @@ namespace CryptoExchange.Net.OrderBook
             get
             {
                 lock (_bookLock)
-                    return _asks.FirstOrDefault().Value ?? _emptySymbolOrderBookEntry;
+                    return asks.FirstOrDefault().Value ?? emptySymbolOrderBookEntry;
             }
         }
 
@@ -191,39 +192,32 @@ namespace CryptoExchange.Net.OrderBook
         /// <summary>
         /// ctor
         /// </summary>
-        /// <param name="logger">Logger to use. If not provided will create a TraceLogger</param>
         /// <param name="id">The id of the order book. Should be set to {Exchange}[{type}], for example: Kucoin[Spot]</param>
         /// <param name="symbol">The symbol the order book is for</param>
-        protected SymbolOrderBook(ILogger? logger, string id, string symbol)
+        /// <param name="options">The options for the order book</param>
+        protected SymbolOrderBook(string id, string symbol, OrderBookOptions options)
         {
             if (symbol == null)
                 throw new ArgumentNullException(nameof(symbol));
 
-            Id = id;
-            _processBuffer = new List<ProcessBufferRangeSequenceEntry>();
-            _processQueue = new ConcurrentQueue<object>();
-            _queueEvent = new AsyncResetEvent(false, true);
-
-            Symbol = symbol;
-            Status = OrderBookStatus.Disconnected;
-
-            _asks = new SortedList<decimal, ISymbolOrderBookEntry>();
-            _bids = new SortedList<decimal, ISymbolOrderBookEntry>(new DescComparer<decimal>());
-
-            _logger = logger ?? new TraceLogger();
-        }
-
-        /// <summary>
-        /// Initialize the order book using the provided options
-        /// </summary>
-        /// <param name="options">The options</param>
-        /// <exception cref="ArgumentNullException"></exception>
-        protected void Initialize(OrderBookOptions options)
-        {
             if (options == null)
                 throw new ArgumentNullException(nameof(options));
 
+            Id = id;
+            processBuffer = new List<ProcessBufferRangeSequenceEntry>();
+            _processQueue = new ConcurrentQueue<object>();
+            _queueEvent = new AsyncResetEvent(false, true);
+
             _validateChecksum = options.ChecksumValidationEnabled;
+            Symbol = symbol;
+            Status = OrderBookStatus.Disconnected;
+
+            asks = new SortedList<decimal, ISymbolOrderBookEntry>();
+            bids = new SortedList<decimal, ISymbolOrderBookEntry>(new DescComparer<decimal>());
+
+            log = new Log(id) { Level = options.LogLevel };
+            var writers = options.LogWriters ?? new List<ILogger> { new DebugLogger() };
+            log.UpdateWriters(writers.ToList());
         }
 
         /// <inheritdoc/>
@@ -232,7 +226,7 @@ namespace CryptoExchange.Net.OrderBook
             if (Status != OrderBookStatus.Disconnected)
                 throw new InvalidOperationException($"Can't start book unless state is {OrderBookStatus.Disconnected}. Current state: {Status}");
 
-            _logger.Log(LogLevel.Debug, $"{Id} order book {Symbol} starting");
+            log.Write(LogLevel.Debug, $"{Id} order book {Symbol} starting");
             _cts = new CancellationTokenSource();
             ct?.Register(async () =>
             {
@@ -242,8 +236,8 @@ namespace CryptoExchange.Net.OrderBook
 
             // Clear any previous messages
             while (_processQueue.TryDequeue(out _)) { }
-            _processBuffer.Clear();
-            _bookSet = false;
+            processBuffer.Clear();
+            bookSet = false;
 
             Status = OrderBookStatus.Connecting;
             _processTask = Task.Factory.StartNew(ProcessQueue, TaskCreationOptions.LongRunning);
@@ -257,7 +251,7 @@ namespace CryptoExchange.Net.OrderBook
 
             if (_cts.IsCancellationRequested)
             {
-                _logger.Log(LogLevel.Debug, $"{Id} order book {Symbol} stopped while starting");
+                log.Write(LogLevel.Debug, $"{Id} order book {Symbol} stopped while starting");
                 await startResult.Data.CloseAsync().ConfigureAwait(false);
                 Status = OrderBookStatus.Disconnected;
                 return new CallResult<bool>(new CancellationRequestedError());
@@ -273,7 +267,7 @@ namespace CryptoExchange.Net.OrderBook
         }
 
         private void HandleConnectionLost() {
-             _logger.Log(LogLevel.Warning, $"{Id} order book {Symbol} connection lost");
+             log.Write(LogLevel.Warning, $"{Id} order book {Symbol} connection lost");
              if (Status != OrderBookStatus.Disposed) {
                 Status = OrderBookStatus.Reconnecting;
                 Reset();
@@ -281,7 +275,7 @@ namespace CryptoExchange.Net.OrderBook
         }
 
         private void HandleConnectionClosed() {
-            _logger.Log(LogLevel.Warning, $"{Id} order book {Symbol} disconnected");
+            log.Write(LogLevel.Warning, $"{Id} order book {Symbol} disconnected");
             Status = OrderBookStatus.Disconnected;
             _ = StopAsync();
         }
@@ -293,7 +287,7 @@ namespace CryptoExchange.Net.OrderBook
         /// <inheritdoc/>
         public async Task StopAsync()
         {
-            _logger.Log(LogLevel.Debug, $"{Id} order book {Symbol} stopping");
+            log.Write(LogLevel.Debug, $"{Id} order book {Symbol} stopping");
             Status = OrderBookStatus.Disconnected;
             _cts?.Cancel();
             _queueEvent.Set();
@@ -306,21 +300,21 @@ namespace CryptoExchange.Net.OrderBook
                 _subscription.ConnectionClosed -= HandleConnectionClosed;
                 _subscription.ConnectionRestored -= HandleConnectionRestored;
             }
-            _logger.Log(LogLevel.Trace, $"{Id} order book {Symbol} stopped");
+            log.Write(LogLevel.Trace, $"{Id} order book {Symbol} stopped");
         }
 
         /// <inheritdoc/>
-        public CallResult<decimal> CalculateAverageFillPrice(decimal baseQuantity, OrderBookEntryType type)
+        public CallResult<decimal> CalculateAverageFillPrice(decimal quantity, OrderBookEntryType type)
         {
             if (Status != OrderBookStatus.Synced)
                 return new CallResult<decimal>(new InvalidOperationError($"{nameof(CalculateAverageFillPrice)} is not available when book is not in Synced state"));
 
             var totalCost = 0m;
             var totalAmount = 0m;
-            var amountLeft = baseQuantity;
+            var amountLeft = quantity;
             lock (_bookLock)
             {
-                var list = type == OrderBookEntryType.Ask ? _asks : _bids;
+                var list = type == OrderBookEntryType.Ask ? asks : bids;
                 
                 var step = 0;
                 while (amountLeft > 0)
@@ -340,35 +334,6 @@ namespace CryptoExchange.Net.OrderBook
             return new CallResult<decimal>(Math.Round(totalCost / totalAmount, 8));
         }
 
-        /// <inheritdoc/>
-        public CallResult<decimal> CalculateTradableAmount(decimal quoteQuantity, OrderBookEntryType type)
-        {
-            if (Status != OrderBookStatus.Synced)
-                return new CallResult<decimal>(new InvalidOperationError($"{nameof(CalculateTradableAmount)} is not available when book is not in Synced state"));
-
-            var quoteQuantityLeft = quoteQuantity;
-            var totalBaseQuantity = 0m;
-            lock (_bookLock)
-            {
-                var list = type == OrderBookEntryType.Ask ? _asks : _bids;
-
-                var step = 0;
-                while (quoteQuantityLeft > 0)
-                {
-                    if (step == list.Count)
-                        return new CallResult<decimal>(new InvalidOperationError("Quantity is larger than order in the order book"));
-
-                    var element = list.ElementAt(step);
-                    var stepAmount = Math.Min(element.Value.Quantity * element.Value.Price, quoteQuantityLeft);
-                    quoteQuantityLeft -= stepAmount;
-                    totalBaseQuantity += stepAmount / element.Value.Price;
-                    step++;
-                }
-            }
-
-            return new CallResult<decimal>(Math.Round(totalBaseQuantity, 8));
-        }
-
         /// <summary>
         /// Implementation for starting the order book. Should typically have logic for subscribing to the update stream and retrieving
         /// and setting the initial order book
@@ -462,14 +427,14 @@ namespace CryptoExchange.Net.OrderBook
         /// </summary>
         protected void CheckProcessBuffer()
         {
-            var pbList = _processBuffer.ToList();
+            var pbList = processBuffer.ToList();
             if (pbList.Count > 0)
-                _logger.Log(LogLevel.Debug, $"Processing {pbList.Count} buffered updates");
+                log.Write(LogLevel.Debug, $"Processing {pbList.Count} buffered updates");
 
             foreach (var bufferEntry in pbList)
             {
                 ProcessRangeUpdates(bufferEntry.FirstUpdateId, bufferEntry.LastUpdateId, bufferEntry.Bids, bufferEntry.Asks);
-                _processBuffer.Remove(bufferEntry);
+                processBuffer.Remove(bufferEntry);
             }
         }
 
@@ -483,21 +448,21 @@ namespace CryptoExchange.Net.OrderBook
         {
             if (sequence <= LastSequenceNumber)
             {
-                _logger.Log(LogLevel.Debug, $"{Id} order book {Symbol} update skipped #{sequence}, currently at #{LastSequenceNumber}");
+                log.Write(LogLevel.Debug, $"{Id} order book {Symbol} update skipped #{sequence}, currently at #{LastSequenceNumber}");
                 return false;
             }
 
-            if (_sequencesAreConsecutive && sequence > LastSequenceNumber + 1)
+            if (sequencesAreConsecutive && sequence > LastSequenceNumber + 1)
             {
                 // Out of sync
-                _logger.Log(LogLevel.Warning, $"{Id} order book {Symbol} out of sync (expected { LastSequenceNumber + 1}, was {sequence}), reconnecting");
+                log.Write(LogLevel.Warning, $"{Id} order book {Symbol} out of sync (expected { LastSequenceNumber + 1}, was {sequence}), reconnecting");
                 _stopProcessing = true;
                 Resubscribe();
                 return false;
             }
 
             UpdateTime = DateTime.UtcNow;
-            var listToChange = type == OrderBookEntryType.Ask ? _asks : _bids;
+            var listToChange = type == OrderBookEntryType.Ask ? asks : bids;
             if (entry.Quantity == 0)
             {
                 if (!listToChange.ContainsKey(entry.Price))
@@ -533,7 +498,7 @@ namespace CryptoExchange.Net.OrderBook
         protected async Task<CallResult<bool>> WaitForSetOrderBookAsync(TimeSpan timeout, CancellationToken ct)
         {
             var startWait = DateTime.UtcNow;
-            while (!_bookSet && Status == OrderBookStatus.Syncing)
+            while (!bookSet && Status == OrderBookStatus.Syncing)
             {
                 if(ct.IsCancellationRequested)
                     return new CallResult<bool>(new CancellationRequestedError());
@@ -575,9 +540,9 @@ namespace CryptoExchange.Net.OrderBook
             // Clear queue
             while (_processQueue.TryDequeue(out _)) { }
 
-            _processBuffer.Clear();
-            _asks.Clear();
-            _bids.Clear();
+            processBuffer.Clear();
+            asks.Clear();
+            bids.Clear();
             AskCount = 0;
             BidCount = 0;
 
@@ -616,9 +581,7 @@ namespace CryptoExchange.Net.OrderBook
             var (bestBid, bestAsk) = BestOffers;
             if (bestBid.Price != prevBestBid.Price || bestBid.Quantity != prevBestBid.Quantity ||
                    bestAsk.Price != prevBestAsk.Price || bestAsk.Quantity != prevBestAsk.Quantity)
-            {
                 OnBestOffersChanged?.Invoke((bestBid, bestAsk));
-            }
         }
 
         private void Reset()
@@ -626,8 +589,8 @@ namespace CryptoExchange.Net.OrderBook
             _queueEvent.Set();
             // Clear queue
             while (_processQueue.TryDequeue(out _)) { }
-            _processBuffer.Clear();
-            _bookSet = false;
+            processBuffer.Clear();
+            bookSet = false;
             DoReset();
         }
 
@@ -644,7 +607,7 @@ namespace CryptoExchange.Net.OrderBook
                 success = resyncResult;
             }
 
-            _logger.Log(LogLevel.Information, $"{Id} order book {Symbol} successfully resynchronized");
+            log.Write(LogLevel.Information, $"{Id} order book {Symbol} successfully resynchronized");
             Status = OrderBookStatus.Synced;
         }
 
@@ -661,7 +624,7 @@ namespace CryptoExchange.Net.OrderBook
 
                     if (_stopProcessing)
                     {
-                        _logger.Log(LogLevel.Trace, "Skipping message because of resubscribing");
+                        log.Write(LogLevel.Trace, "Skipping message because of resubscribing");
                         continue;
                     }
 
@@ -679,21 +642,21 @@ namespace CryptoExchange.Net.OrderBook
         {
             lock (_bookLock)
             {
-                _bookSet = true;
-                _asks.Clear();
+                bookSet = true;
+                asks.Clear();
                 foreach (var ask in item.Asks)
-                    _asks.Add(ask.Price, ask);
-                _bids.Clear();
+                    asks.Add(ask.Price, ask);
+                bids.Clear();
                 foreach (var bid in item.Bids)
-                    _bids.Add(bid.Price, bid);
+                    bids.Add(bid.Price, bid);
 
                 LastSequenceNumber = item.EndUpdateId;
 
-                AskCount = _asks.Count;
-                BidCount = _bids.Count;
+                AskCount = asks.Count;
+                BidCount = bids.Count;
 
                 UpdateTime = DateTime.UtcNow;
-                _logger.Log(LogLevel.Debug, $"{Id} order book {Symbol} data set: {BidCount} bids, {AskCount} asks. #{item.EndUpdateId}");
+                log.Write(LogLevel.Debug, $"{Id} order book {Symbol} data set: {BidCount} bids, {AskCount} asks. #{item.EndUpdateId}");
                 CheckProcessBuffer();
                 OnOrderBookUpdate?.Invoke((item.Bids, item.Asks));
                 OnBestOffersChanged?.Invoke((BestBid, BestAsk));
@@ -704,16 +667,16 @@ namespace CryptoExchange.Net.OrderBook
         {
             lock (_bookLock)
             {
-                if (!_bookSet)
+                if (!bookSet)
                 {
-                    _processBuffer.Add(new ProcessBufferRangeSequenceEntry()
+                    processBuffer.Add(new ProcessBufferRangeSequenceEntry()
                     {
                         Asks = item.Asks,
                         Bids = item.Bids,
                         FirstUpdateId = item.StartUpdateId,
                         LastUpdateId = item.EndUpdateId,
                     });
-                    _logger.Log(LogLevel.Trace, $"{Id} order book {Symbol} update buffered #{item.StartUpdateId}-#{item.EndUpdateId} [{item.Asks.Count()} asks, {item.Bids.Count()} bids]");
+                    log.Write(LogLevel.Trace, $"{Id} order book {Symbol} update buffered #{item.StartUpdateId}-#{item.EndUpdateId} [{item.Asks.Count()} asks, {item.Bids.Count()} bids]");
                 }
                 else
                 {
@@ -721,12 +684,12 @@ namespace CryptoExchange.Net.OrderBook
                     var (prevBestBid, prevBestAsk) = BestOffers;
                     ProcessRangeUpdates(item.StartUpdateId, item.EndUpdateId, item.Bids, item.Asks);
 
-                    if (!_asks.Any() || !_bids.Any())
+                    if (!asks.Any() || !bids.Any())
                         return;
 
-                    if (_asks.First().Key < _bids.First().Key)
+                    if (asks.First().Key < bids.First().Key)
                     {
-                        _logger.Log(LogLevel.Warning, $"{Id} order book {Symbol} detected out of sync order book. First ask: {_asks.First().Key}, first bid: {_bids.First().Key}. Resyncing");
+                        log.Write(LogLevel.Warning, $"{Id} order book {Symbol} detected out of sync order book. First ask: {asks.First().Key}, first bid: {bids.First().Key}. Resyncing");
                         _stopProcessing = true;
                         Resubscribe();
                         return;
@@ -760,7 +723,7 @@ namespace CryptoExchange.Net.OrderBook
 
                 if (!checksumResult)
                 {
-                    _logger.Log(LogLevel.Warning, $"{Id} order book {Symbol} out of sync. Resyncing");
+                    log.Write(LogLevel.Warning, $"{Id} order book {Symbol} out of sync. Resyncing");
                     _stopProcessing = true;
                     Resubscribe();
                 }
@@ -784,14 +747,12 @@ namespace CryptoExchange.Net.OrderBook
                 if (!await _subscription!.ResubscribeAsync().ConfigureAwait(false))
                 {
                     // Resubscribing failed, reconnect the socket
-                    _logger.Log(LogLevel.Warning, $"{Id} order book {Symbol} resync failed, reconnecting socket");
+                    log.Write(LogLevel.Warning, $"{Id} order book {Symbol} resync failed, reconnecting socket");
                     Status = OrderBookStatus.Reconnecting;
                     _ = _subscription!.ReconnectAsync();
                 }
                 else
-                {
                     await ResyncAsync().ConfigureAwait(false);
-                }
             });
         }
 
@@ -799,7 +760,7 @@ namespace CryptoExchange.Net.OrderBook
         {
             if (lastUpdateId <= LastSequenceNumber)
             {
-                _logger.Log(LogLevel.Trace, $"{Id} order book {Symbol} update skipped #{firstUpdateId}-{lastUpdateId}");
+                log.Write(LogLevel.Trace, $"{Id} order book {Symbol} update skipped #{firstUpdateId}-{lastUpdateId}");
                 return;
             }
 
@@ -809,23 +770,23 @@ namespace CryptoExchange.Net.OrderBook
             foreach (var entry in asks)
                 ProcessUpdate(LastSequenceNumber + 1, OrderBookEntryType.Ask, entry);
 
-            if (Levels.HasValue && _strictLevels)
+            if (Levels.HasValue && strictLevels)
             {
-                while (this._bids.Count > Levels.Value)
+                while (this.bids.Count > Levels.Value)
                 {
                     BidCount--;
-                    this._bids.Remove(this._bids.Last().Key);
+                    this.bids.Remove(this.bids.Last().Key);
                 }
 
-                while (this._asks.Count > Levels.Value)
+                while (this.asks.Count > Levels.Value)
                 {
                     AskCount--;
-                    this._asks.Remove(this._asks.Last().Key);
+                    this.asks.Remove(this.asks.Last().Key);
                 }
             }
 
             LastSequenceNumber = lastUpdateId;
-            _logger.Log(LogLevel.Trace, $"{Id} order book {Symbol} update processed #{firstUpdateId}-{lastUpdateId}");
+            log.Write(LogLevel.Trace, $"{Id} order book {Symbol} update processed #{firstUpdateId}-{lastUpdateId}");
         }        
     }
 

CryptoExchange.Net/Requests/Request.cs

@@ -15,8 +15,8 @@ namespace CryptoExchange.Net.Requests
     /// </summary>
     public class Request : IRequest
     {
-        private readonly HttpRequestMessage _request;
-        private readonly HttpClient _httpClient;
+        private readonly HttpRequestMessage request;
+        private readonly HttpClient httpClient;
 
         /// <summary>
         /// Create request object for web request
@@ -26,8 +26,8 @@ namespace CryptoExchange.Net.Requests
         /// <param name="requestId"></param>        
         public Request(HttpRequestMessage request, HttpClient client, int requestId)
         {
-            _httpClient = client;
-            _request = request;
+            httpClient = client;
+            this.request = request;
             RequestId = requestId;
         }
         
@@ -37,18 +37,18 @@ namespace CryptoExchange.Net.Requests
         /// <inheritdoc />
         public string Accept
         {
-            set => _request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(value));
+            set => request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(value));
         }
 
         /// <inheritdoc />
         public HttpMethod Method
         {
-            get => _request.Method;
-            set => _request.Method = value;
+            get => request.Method;
+            set => request.Method = value;
         }
 
         /// <inheritdoc />
-        public Uri Uri => _request.RequestUri;
+        public Uri Uri => request.RequestUri;
 
         /// <inheritdoc />
         public int RequestId { get; }
@@ -57,31 +57,31 @@ namespace CryptoExchange.Net.Requests
         public void SetContent(string data, string contentType)
         {
             Content = data;
-            _request.Content = new StringContent(data, Encoding.UTF8, contentType);
+            request.Content = new StringContent(data, Encoding.UTF8, contentType);
         }
 
         /// <inheritdoc />
         public void AddHeader(string key, string value)
         {
-            _request.Headers.Add(key, value);
+            request.Headers.Add(key, value);
         }
 
         /// <inheritdoc />
         public Dictionary<string, IEnumerable<string>> GetHeaders()
         {
-            return _request.Headers.ToDictionary(h => h.Key, h => h.Value);
+            return request.Headers.ToDictionary(h => h.Key, h => h.Value);
         }
 
         /// <inheritdoc />
         public void SetContent(byte[] data)
         {
-            _request.Content = new ByteArrayContent(data);
+            request.Content = new ByteArrayContent(data);
         }
 
         /// <inheritdoc />
         public async Task<IResponse> GetResponseAsync(CancellationToken cancellationToken)
         {
-            return new Response(await _httpClient.SendAsync(_request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false));
+            return new Response(await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false));
         }
     }
 }

CryptoExchange.Net/Requests/RequestFactory.cs

@@ -1,10 +1,8 @@
 using System;
 using System.Net;
 using System.Net.Http;
-using System.Runtime.InteropServices;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
 
 namespace CryptoExchange.Net.Requests
 {
@@ -13,39 +11,37 @@ namespace CryptoExchange.Net.Requests
     /// </summary>
     public class RequestFactory : IRequestFactory
     {
-        private HttpClient? _httpClient;        
+        private HttpClient? httpClient;        
 
         /// <inheritdoc />
-        public void Configure(ApiProxy? proxy, TimeSpan requestTimeout, HttpClient? client = null)
+        public void Configure(TimeSpan requestTimeout, ApiProxy? proxy, HttpClient? client = null)
         {
             if (client == null)
             {
-                var handler = new HttpClientHandler();
-                if (proxy != null)
+                HttpMessageHandler handler = new HttpClientHandler()
                 {
-                    handler.Proxy = new WebProxy
+                    Proxy = proxy == null ? null : new WebProxy
                     {
                         Address = new Uri($"{proxy.Host}:{proxy.Port}"),
                         Credentials = proxy.Password == null ? null : new NetworkCredential(proxy.Login, proxy.Password)
-                    };
-                }
-
-                client = new HttpClient(handler)
-                {
-                    Timeout = requestTimeout
+                    }
                 };
-            }
 
-            _httpClient = client;
+                httpClient = new HttpClient(handler) { Timeout = requestTimeout };
+            }
+            else
+            {
+                httpClient = client;                
+            }
         }
 
         /// <inheritdoc />
         public IRequest Create(HttpMethod method, Uri uri, int requestId)
         {
-            if (_httpClient == null)
+            if (httpClient == null)
                 throw new InvalidOperationException("Cant create request before configuring http client");
 
-            return new Request(new HttpRequestMessage(method, uri), _httpClient, requestId);
+            return new Request(new HttpRequestMessage(method, uri), httpClient, requestId);
         }
     }
 }

CryptoExchange.Net/Requests/Response.cs

@@ -12,19 +12,16 @@ namespace CryptoExchange.Net.Requests
     /// </summary>
     internal class Response : IResponse
     {
-        private readonly HttpResponseMessage _response;
+        private readonly HttpResponseMessage response;
 
         /// <inheritdoc />
-        public HttpStatusCode StatusCode => _response.StatusCode;
+        public HttpStatusCode StatusCode => response.StatusCode;
 
         /// <inheritdoc />
-        public bool IsSuccessStatusCode => _response.IsSuccessStatusCode;
+        public bool IsSuccessStatusCode => response.IsSuccessStatusCode;
 
         /// <inheritdoc />
-        public long? ContentLength => _response.Content.Headers.ContentLength;
-
-        /// <inheritdoc />
-        public IEnumerable<KeyValuePair<string, IEnumerable<string>>> ResponseHeaders => _response.Headers;
+        public IEnumerable<KeyValuePair<string, IEnumerable<string>>> ResponseHeaders => response.Headers;
 
         /// <summary>
         /// Create response for a http response message
@@ -32,19 +29,19 @@ namespace CryptoExchange.Net.Requests
         /// <param name="response">The actual response</param>
         public Response(HttpResponseMessage response)
         {
-            this._response = response;
+            this.response = response;
         }
 
         /// <inheritdoc />
         public async Task<Stream> GetResponseStreamAsync()
         {
-            return await _response.Content.ReadAsStreamAsync().ConfigureAwait(false);
+            return await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public void Close()
         {
-            _response.Dispose();
+            response.Dispose();
         }
     }
 }

CryptoExchange.Net/Sockets/CryptoExchangeWebSocketClient.cs

@@ -1,4 +1,5 @@
 using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Logging;
 using CryptoExchange.Net.Objects;
 using Microsoft.Extensions.Logging;
 using System;
@@ -7,7 +8,6 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Net;
-using System.Net.Http;
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
@@ -27,12 +27,14 @@ namespace CryptoExchange.Net.Sockets
             Reconnecting
         }
 
-        internal static int _lastStreamId;
-        private static readonly object _streamIdLock = new();
+        internal static int lastStreamId;
+        private static readonly object streamIdLock = new();
 
         private readonly AsyncResetEvent _sendEvent;
-        private readonly ConcurrentQueue<SendItem> _sendBuffer;
+        private readonly ConcurrentQueue<byte[]> _sendBuffer;
         private readonly SemaphoreSlim _closeSem;
+        private readonly WebSocketParameters _parameters;
+        private readonly List<DateTime> _outgoingMessages;
 
         private ClientWebSocket _socket;
         private CancellationTokenSource _ctsSource;
@@ -42,7 +44,6 @@ namespace CryptoExchange.Net.Sockets
         private bool _stopRequested;
         private bool _disposed;
         private ProcessState _processState;
-        private DateTime _lastReconnectTime;
 
 
         /// <summary>
@@ -58,21 +59,18 @@ namespace CryptoExchange.Net.Sockets
         /// <summary>
         /// Log
         /// </summary>
-        protected ILogger _logger;
+        protected Log _log;
 
         /// <inheritdoc />
         public int Id { get; }
 
-        /// <inheritdoc />
-        public WebSocketParameters Parameters { get; }
-
         /// <summary>
         /// The timestamp this socket has been active for the last time
         /// </summary>
         public DateTime LastActionTime { get; private set; }
         
         /// <inheritdoc />
-        public Uri Uri => Parameters.Uri;
+        public Uri Uri => _parameters.Uri;
 
         /// <inheritdoc />
         public bool IsClosed => _socket.State == WebSocketState.Closed;
@@ -99,41 +97,32 @@ namespace CryptoExchange.Net.Sockets
 
         /// <inheritdoc />
         public event Action? OnClose;
-
         /// <inheritdoc />
         public event Action<string>? OnMessage;
-
-        /// <inheritdoc />
-        public event Action<int>? OnRequestSent;
-
         /// <inheritdoc />
         public event Action<Exception>? OnError;
-
         /// <inheritdoc />
         public event Action? OnOpen;
-
         /// <inheritdoc />
         public event Action? OnReconnecting;
-
         /// <inheritdoc />
         public event Action? OnReconnected;
-        /// <inheritdoc />
-        public Func<Task<Uri?>>? GetReconnectionUrl { get; set; }
 
         /// <summary>
         /// ctor
         /// </summary>
-        /// <param name="logger">The log object to use</param>
+        /// <param name="log">The log object to use</param>
         /// <param name="websocketParameters">The parameters for this socket</param>
-        public CryptoExchangeWebSocketClient(ILogger logger, WebSocketParameters websocketParameters)
+        public CryptoExchangeWebSocketClient(Log log, WebSocketParameters websocketParameters)
         {
             Id = NextStreamId();
-            _logger = logger;
+            _log = log;
 
-            Parameters = websocketParameters;
+            _parameters = websocketParameters;
+            _outgoingMessages = new List<DateTime>();
             _receivedMessages = new List<ReceiveItem>();
             _sendEvent = new AsyncResetEvent();
-            _sendBuffer = new ConcurrentQueue<SendItem>();
+            _sendBuffer = new ConcurrentQueue<byte[]>();
             _ctsSource = new CancellationTokenSource();
             _receivedMessagesLock = new object();
 
@@ -158,32 +147,23 @@ namespace CryptoExchange.Net.Sockets
         private ClientWebSocket CreateSocket()
         {
             var cookieContainer = new CookieContainer();
-            foreach (var cookie in Parameters.Cookies)
+            foreach (var cookie in _parameters.Cookies)
                 cookieContainer.Add(new Cookie(cookie.Key, cookie.Value));
 
             var socket = new ClientWebSocket();
-            try
-            {
-                socket.Options.Cookies = cookieContainer;
-                foreach (var header in Parameters.Headers)
-                    socket.Options.SetRequestHeader(header.Key, header.Value);
-                socket.Options.KeepAliveInterval = Parameters.KeepAliveInterval ?? TimeSpan.Zero;
-                socket.Options.SetBuffer(65536, 65536); // Setting it to anything bigger than 65536 throws an exception in .net framework
-                if (Parameters.Proxy != null)
-                    SetProxy(socket, Parameters.Proxy);
-            }
-            catch (PlatformNotSupportedException)
-            {
-                // Options are not supported on certain platforms (WebAssembly for instance)
-                // best we can do it try to connect without setting options.
-            }
-
+            socket.Options.Cookies = cookieContainer;
+            foreach (var header in _parameters.Headers)
+                socket.Options.SetRequestHeader(header.Key, header.Value);
+            socket.Options.KeepAliveInterval = _parameters.KeepAliveInterval ?? TimeSpan.Zero;
+            socket.Options.SetBuffer(65536, 65536); // Setting it to anything bigger than 65536 throws an exception in .net framework
+            if (_parameters.Proxy != null)
+                SetProxy(_parameters.Proxy);
             return socket;
         }
 
         private async Task<bool> ConnectInternalAsync()
         {
-            _logger.Log(LogLevel.Debug, $"Socket {Id} connecting");
+            _log.Write(LogLevel.Debug, $"Socket {Id} connecting");
             try
             {
                 using CancellationTokenSource tcs = new(TimeSpan.FromSeconds(10));
@@ -191,11 +171,11 @@ namespace CryptoExchange.Net.Sockets
             }
             catch (Exception e)
             {
-                _logger.Log(LogLevel.Debug, $"Socket {Id} connection failed: " + e.ToLogString());
+                _log.Write(LogLevel.Debug, $"Socket {Id} connection failed: " + e.ToLogString());
                 return false;
             }
 
-            _logger.Log(LogLevel.Debug, $"Socket {Id} connected to {Uri}");
+            _log.Write(LogLevel.Debug, $"Socket {Id} connected to {Uri}");
             return true;
         }
 
@@ -204,13 +184,13 @@ namespace CryptoExchange.Net.Sockets
         {
             while (!_stopRequested)
             {
-                _logger.Log(LogLevel.Debug, $"Socket {Id} starting processing tasks");
+                _log.Write(LogLevel.Debug, $"Socket {Id} starting processing tasks");
                 _processState = ProcessState.Processing;
                 var sendTask = SendLoopAsync();
                 var receiveTask = ReceiveLoopAsync();
-                var timeoutTask = Parameters.Timeout != null && Parameters.Timeout > TimeSpan.FromSeconds(0) ? CheckTimeoutAsync() : Task.CompletedTask;
+                var timeoutTask = _parameters.Timeout != null && _parameters.Timeout > TimeSpan.FromSeconds(0) ? CheckTimeoutAsync() : Task.CompletedTask;
                 await Task.WhenAll(sendTask, receiveTask, timeoutTask).ConfigureAwait(false);
-                _logger.Log(LogLevel.Debug, $"Socket {Id} processing tasks finished");
+                _log.Write(LogLevel.Debug, $"Socket {Id} processing tasks finished");
 
                 _processState = ProcessState.WaitingForClose;
                 while (_closeTask == null)
@@ -219,7 +199,7 @@ namespace CryptoExchange.Net.Sockets
                 await _closeTask.ConfigureAwait(false);
                 _closeTask = null;
 
-                if (!Parameters.AutoReconnect)
+                if (!_parameters.AutoReconnect)
                 {
                     _processState = ProcessState.Idle;
                     OnClose?.Invoke();
@@ -229,27 +209,12 @@ namespace CryptoExchange.Net.Sockets
                 if (!_stopRequested)
                 {
                     _processState = ProcessState.Reconnecting;
-                    OnReconnecting?.Invoke();                    
+                    OnReconnecting?.Invoke();
                 }
 
-                var sinceLastReconnect = DateTime.UtcNow - _lastReconnectTime;
-                if (sinceLastReconnect < Parameters.ReconnectInterval)
-                    await Task.Delay(Parameters.ReconnectInterval - sinceLastReconnect).ConfigureAwait(false);
-
                 while (!_stopRequested)
                 {
-                    _logger.Log(LogLevel.Debug, $"Socket {Id} attempting to reconnect");
-                    var task = GetReconnectionUrl?.Invoke();
-                    if (task != null)
-                    {
-                        var reconnectUri = await task.ConfigureAwait(false);
-                        if (reconnectUri != null && Parameters.Uri != reconnectUri)
-                        {
-                            _logger.Log(LogLevel.Debug, $"Socket {Id} reconnect URI set to {reconnectUri}");
-                            Parameters.Uri = reconnectUri;
-                        }
-                    }
-
+                    _log.Write(LogLevel.Debug, $"Socket {Id} attempting to reconnect");
                     _socket = CreateSocket();
                     _ctsSource.Dispose();
                     _ctsSource = new CancellationTokenSource();
@@ -258,11 +223,10 @@ namespace CryptoExchange.Net.Sockets
                     var connected = await ConnectInternalAsync().ConfigureAwait(false);
                     if (!connected)
                     {
-                        await Task.Delay(Parameters.ReconnectInterval).ConfigureAwait(false);
+                        await Task.Delay(_parameters.ReconnectInterval).ConfigureAwait(false);
                         continue;
                     }
 
-                    _lastReconnectTime = DateTime.UtcNow;
                     OnReconnected?.Invoke();
                     break;
                 }
@@ -272,24 +236,24 @@ namespace CryptoExchange.Net.Sockets
         }
 
         /// <inheritdoc />
-        public virtual void Send(int id, string data, int weight)
+        public virtual void Send(string data)
         {
             if (_ctsSource.IsCancellationRequested)
                 return;
 
-            var bytes = Parameters.Encoding.GetBytes(data);
-            _logger.Log(LogLevel.Trace, $"Socket {Id} - msg {id} - Adding {bytes.Length} bytes to send buffer");
-            _sendBuffer.Enqueue(new SendItem { Id = id, Weight = weight, Bytes = bytes });
+            var bytes = _parameters.Encoding.GetBytes(data);
+            _log.Write(LogLevel.Trace, $"Socket {Id} Adding {bytes.Length} to sent buffer");
+            _sendBuffer.Enqueue(bytes);
             _sendEvent.Set();
         }
 
         /// <inheritdoc />
         public virtual async Task ReconnectAsync()
         {
-            if (_processState != ProcessState.Processing && IsOpen)
+            if (_processState != ProcessState.Processing)
                 return;
 
-            _logger.Log(LogLevel.Debug, $"Socket {Id} reconnect requested");
+            _log.Write(LogLevel.Debug, $"Socket {Id} reconnect requested");
             _closeTask = CloseInternalAsync();
             await _closeTask.ConfigureAwait(false);
         }
@@ -298,24 +262,24 @@ namespace CryptoExchange.Net.Sockets
         public virtual async Task CloseAsync()
         {
             await _closeSem.WaitAsync().ConfigureAwait(false);
-            _stopRequested = true;
-
             try
             {
-                if (_closeTask?.IsCompleted == false)
+                if (_closeTask != null && !_closeTask.IsCompleted)
                 {
-                    _logger.Log(LogLevel.Debug, $"Socket {Id} CloseAsync() waiting for existing close task");
+                    _log.Write(LogLevel.Debug, $"Socket {Id} CloseAsync() waiting for existing close task");
                     await _closeTask.ConfigureAwait(false);
                     return;
                 }
 
+                _stopRequested = true;
+
                 if (!IsOpen)
                 {
-                    _logger.Log(LogLevel.Debug, $"Socket {Id} CloseAsync() socket not open");
+                    _log.Write(LogLevel.Debug, $"Socket {Id} CloseAsync() socket not open");
                     return;
                 }
 
-                _logger.Log(LogLevel.Debug, $"Socket {Id} closing");
+                _log.Write(LogLevel.Debug, $"Socket {Id} closing");
                 _closeTask = CloseInternalAsync();
             }
             finally
@@ -327,7 +291,7 @@ namespace CryptoExchange.Net.Sockets
             if(_processTask != null)
                 await _processTask.ConfigureAwait(false);
             OnClose?.Invoke();
-            _logger.Log(LogLevel.Debug, $"Socket {Id} closed");
+            _log.Write(LogLevel.Debug, $"Socket {Id} closed");
         }
 
         /// <summary>
@@ -379,11 +343,11 @@ namespace CryptoExchange.Net.Sockets
             if (_disposed)
                 return;
 
-            _logger.Log(LogLevel.Debug, $"Socket {Id} disposing");
+            _log.Write(LogLevel.Debug, $"Socket {Id} disposing");
             _disposed = true;
             _socket.Dispose();
             _ctsSource.Dispose();
-            _logger.Log(LogLevel.Trace, $"Socket {Id} disposed");
+            _log.Write(LogLevel.Trace, $"Socket {Id} disposed");
         }
 
         /// <summary>
@@ -394,7 +358,6 @@ namespace CryptoExchange.Net.Sockets
         {
             try
             {
-                var limitKey = Uri.ToString() + "/" + Id.ToString();
                 while (true)
                 {
                     if (_ctsSource.IsCancellationRequested)
@@ -407,24 +370,25 @@ namespace CryptoExchange.Net.Sockets
 
                     while (_sendBuffer.TryDequeue(out var data))
                     {
-                        if (Parameters.RateLimiters != null)
+                        if (_parameters.RatelimitPerSecond != null)
                         {
-                            foreach(var ratelimiter in Parameters.RateLimiters)
+                            // Wait for rate limit
+                            DateTime? start = null;
+                            while (MessagesSentLastSecond() >= _parameters.RatelimitPerSecond)
                             {
-                                var limitResult = await ratelimiter.LimitRequestAsync(_logger, limitKey, HttpMethod.Get, false, null, RateLimitingBehaviour.Wait, data.Weight, _ctsSource.Token).ConfigureAwait(false);
-                                if (limitResult.Success)
-                                {
-                                    if (limitResult.Data > 0)
-                                        _logger.Log(LogLevel.Debug, $"Socket {Id} - msg {data.Id} - send delayed {limitResult.Data}ms because of rate limit");
-                                }
+                                start ??= DateTime.UtcNow;
+                                await Task.Delay(50).ConfigureAwait(false);
                             }
+
+                            if (start != null)
+                                _log.Write(LogLevel.Debug, $"Socket {Id} sent delayed {Math.Round((DateTime.UtcNow - start.Value).TotalMilliseconds)}ms because of rate limit");
                         }
 
                         try
                         {
-                            await _socket.SendAsync(new ArraySegment<byte>(data.Bytes, 0, data.Bytes.Length), WebSocketMessageType.Text, true, _ctsSource.Token).ConfigureAwait(false);
-                            OnRequestSent?.Invoke(data.Id);
-                            _logger.Log(LogLevel.Trace, $"Socket {Id} - msg {data.Id} - sent {data.Bytes.Length} bytes");
+                            await _socket.SendAsync(new ArraySegment<byte>(data, 0, data.Length), WebSocketMessageType.Text, true, _ctsSource.Token).ConfigureAwait(false);
+                            _outgoingMessages.Add(DateTime.UtcNow);
+                            _log.Write(LogLevel.Trace, $"Socket {Id} sent {data.Length} bytes");
                         }
                         catch (OperationCanceledException)
                         {
@@ -435,8 +399,7 @@ namespace CryptoExchange.Net.Sockets
                         {
                             // Connection closed unexpectedly, .NET framework
                             OnError?.Invoke(ioe);
-                            if (_closeTask?.IsCompleted != false)
-                                _closeTask = CloseInternalAsync();
+                            _closeTask = CloseInternalAsync();
                             break;
                         }
                     }
@@ -447,13 +410,12 @@ namespace CryptoExchange.Net.Sockets
                 // Because this is running in a separate task and not awaited until the socket gets closed
                 // any exception here will crash the send processing, but do so silently unless the socket get's stopped.
                 // Make sure we at least let the owner know there was an error
-                _logger.Log(LogLevel.Warning, $"Socket {Id} Send loop stopped with exception");
                 OnError?.Invoke(e);
                 throw;
             }
             finally
             {
-                _logger.Log(LogLevel.Debug, $"Socket {Id} Send loop finished");
+                _log.Write(LogLevel.Debug, $"Socket {Id} Send loop finished");
             }
         }
 
@@ -493,17 +455,15 @@ namespace CryptoExchange.Net.Sockets
                         {
                             // Connection closed unexpectedly
                             OnError?.Invoke(wse);
-                            if (_closeTask?.IsCompleted != false)
-                                _closeTask = CloseInternalAsync();
+                            _closeTask = CloseInternalAsync();
                             break;
                         }
 
                         if (receiveResult.MessageType == WebSocketMessageType.Close)
                         {
                             // Connection closed unexpectedly        
-                            _logger.Log(LogLevel.Debug, $"Socket {Id} received `Close` message");
-                            if (_closeTask?.IsCompleted != false)
-                                _closeTask = CloseInternalAsync();
+                            _log.Write(LogLevel.Debug, $"Socket {Id} received `Close` message");
+                            _closeTask = CloseInternalAsync();
                             break;
                         }
 
@@ -512,7 +472,7 @@ namespace CryptoExchange.Net.Sockets
                             // We received data, but it is not complete, write it to a memory stream for reassembling
                             multiPartMessage = true;
                             memoryStream ??= new MemoryStream();
-                            _logger.Log(LogLevel.Trace, $"Socket {Id} received {receiveResult.Count} bytes in partial message");
+                            _log.Write(LogLevel.Trace, $"Socket {Id} received {receiveResult.Count} bytes in partial message");
                             await memoryStream.WriteAsync(buffer.Array, buffer.Offset, receiveResult.Count).ConfigureAwait(false);
                         }
                         else
@@ -520,13 +480,13 @@ namespace CryptoExchange.Net.Sockets
                             if (!multiPartMessage)
                             {
                                 // Received a complete message and it's not multi part
-                                _logger.Log(LogLevel.Trace, $"Socket {Id} received {receiveResult.Count} bytes in single message");
+                                _log.Write(LogLevel.Trace, $"Socket {Id} received {receiveResult.Count} bytes in single message");
                                 HandleMessage(buffer.Array!, buffer.Offset, receiveResult.Count, receiveResult.MessageType);
                             }
                             else
                             {
                                 // Received the end of a multipart message, write to memory stream for reassembling
-                                _logger.Log(LogLevel.Trace, $"Socket {Id} received {receiveResult.Count} bytes in partial message");
+                                _log.Write(LogLevel.Trace, $"Socket {Id} received {receiveResult.Count} bytes in partial message");
                                 await memoryStream!.WriteAsync(buffer.Array, buffer.Offset, receiveResult.Count).ConfigureAwait(false);
                             }
                             break;
@@ -554,12 +514,12 @@ namespace CryptoExchange.Net.Sockets
                         if (receiveResult?.EndOfMessage == true)
                         {
                             // Reassemble complete message from memory stream
-                            _logger.Log(LogLevel.Trace, $"Socket {Id} reassembled message of {memoryStream!.Length} bytes");
+                            _log.Write(LogLevel.Trace, $"Socket {Id} reassembled message of {memoryStream!.Length} bytes");
                             HandleMessage(memoryStream!.ToArray(), 0, (int)memoryStream.Length, receiveResult.MessageType);
                             memoryStream.Dispose();
                         }
                         else
-                            _logger.Log(LogLevel.Trace, $"Socket {Id} discarding incomplete message of {memoryStream!.Length} bytes");
+                            _log.Write(LogLevel.Trace, $"Socket {Id} discarding incomplete message of {memoryStream!.Length} bytes");
                     }
                 }
             }
@@ -568,13 +528,12 @@ namespace CryptoExchange.Net.Sockets
                 // Because this is running in a separate task and not awaited until the socket gets closed
                 // any exception here will crash the receive processing, but do so silently unless the socket gets stopped.
                 // Make sure we at least let the owner know there was an error
-                _logger.Log(LogLevel.Warning, $"Socket {Id} Receive loop stopped with exception");
                 OnError?.Invoke(e);
                 throw;
             }
             finally
             {
-                _logger.Log(LogLevel.Debug, $"Socket {Id} Receive loop finished");
+                _log.Write(LogLevel.Debug, $"Socket {Id} Receive loop finished");
             }
         }
 
@@ -590,33 +549,33 @@ namespace CryptoExchange.Net.Sockets
             string strData;
             if (messageType == WebSocketMessageType.Binary)
             {
-                if (Parameters.DataInterpreterBytes == null)
+                if (_parameters.DataInterpreterBytes == null)
                     throw new Exception("Byte interpreter not set while receiving byte data");
 
                 try
                 {
                     var relevantData = new byte[count];
                     Array.Copy(data, offset, relevantData, 0, count);
-                    strData = Parameters.DataInterpreterBytes(relevantData);
+                    strData = _parameters.DataInterpreterBytes(relevantData);
                 }
                 catch(Exception e)
                 {
-                    _logger.Log(LogLevel.Error, $"Socket {Id} unhandled exception during byte data interpretation: " + e.ToLogString());
+                    _log.Write(LogLevel.Error, $"Socket {Id} unhandled exception during byte data interpretation: " + e.ToLogString());
                     return;
                 }
             }
             else
-                strData = Parameters.Encoding.GetString(data, offset, count);
+                strData = _parameters.Encoding.GetString(data, offset, count);
 
-            if (Parameters.DataInterpreterString != null)
+            if (_parameters.DataInterpreterString != null)
             {
                 try
                 {
-                    strData = Parameters.DataInterpreterString(strData);
+                    strData = _parameters.DataInterpreterString(strData);
                 }
                 catch(Exception e)
                 {
-                    _logger.Log(LogLevel.Error, $"Socket {Id} unhandled exception during string data interpretation: " + e.ToLogString());
+                    _log.Write(LogLevel.Error, $"Socket {Id} unhandled exception during string data interpretation: " + e.ToLogString());
                     return;
                 }
             }
@@ -628,17 +587,53 @@ namespace CryptoExchange.Net.Sockets
             }
             catch(Exception e)
             {
-                _logger.Log(LogLevel.Error, $"Socket {Id} unhandled exception during message processing: " + e.ToLogString());
+                _log.Write(LogLevel.Error, $"Socket {Id} unhandled exception during message processing: " + e.ToLogString());
             }
         }
 
+        /// <summary>
+        /// Trigger the OnMessage event
+        /// </summary>
+        /// <param name="data"></param>
+        protected void TriggerOnMessage(string data)
+        {
+            LastActionTime = DateTime.UtcNow;
+            OnMessage?.Invoke(data);
+        }
+
+        /// <summary>
+        /// Trigger the OnError event
+        /// </summary>
+        /// <param name="ex"></param>
+        protected void TriggerOnError(Exception ex) => OnError?.Invoke(ex);
+
+        /// <summary>
+        /// Trigger the OnError event
+        /// </summary>
+        protected void TriggerOnOpen() => OnOpen?.Invoke();
+
+        /// <summary>
+        /// Trigger the OnError event
+        /// </summary>
+        protected void TriggerOnClose() => OnClose?.Invoke();
+
+        /// <summary>
+        /// Trigger the OnReconnecting event
+        /// </summary>
+        protected void TriggerOnReconnecting() => OnReconnecting?.Invoke();
+
+        /// <summary>
+        /// Trigger the OnReconnected event
+        /// </summary>
+        protected void TriggerOnReconnected() => OnReconnected?.Invoke();
+
         /// <summary>
         /// Checks if there is no data received for a period longer than the specified timeout
         /// </summary>
         /// <returns></returns>
         protected async Task CheckTimeoutAsync()
         {
-            _logger.Log(LogLevel.Debug, $"Socket {Id} Starting task checking for no data received for {Parameters.Timeout}");
+            _log.Write(LogLevel.Debug, $"Socket {Id} Starting task checking for no data received for {_parameters.Timeout}");
             LastActionTime = DateTime.UtcNow;
             try 
             { 
@@ -647,10 +642,10 @@ namespace CryptoExchange.Net.Sockets
                     if (_ctsSource.IsCancellationRequested)
                         return;
 
-                    if (DateTime.UtcNow - LastActionTime > Parameters.Timeout)
+                    if (DateTime.UtcNow - LastActionTime > _parameters.Timeout)
                     {
-                        _logger.Log(LogLevel.Warning, $"Socket {Id} No data received for {Parameters.Timeout}, reconnecting socket");
-                        _ = ReconnectAsync().ConfigureAwait(false);
+                        _log.Write(LogLevel.Warning, $"Socket {Id} No data received for {_parameters.Timeout}, reconnecting socket");
+                        _ = CloseAsync().ConfigureAwait(false);
                         return;
                     }
                     try
@@ -680,13 +675,20 @@ namespace CryptoExchange.Net.Sockets
         /// <returns></returns>
         private static int NextStreamId()
         {
-            lock (_streamIdLock)
+            lock (streamIdLock)
             {
-                _lastStreamId++;
-                return _lastStreamId;
+                lastStreamId++;
+                return lastStreamId;
             }
         }
 
+        private int MessagesSentLastSecond()
+        {
+            var testTime = DateTime.UtcNow;
+            _outgoingMessages.RemoveAll(r => testTime - r > TimeSpan.FromSeconds(1));
+            return _outgoingMessages.Count;            
+        }
+
         /// <summary>
         /// Update the received messages list, removing messages received longer than 3s ago
         /// </summary>
@@ -696,10 +698,8 @@ namespace CryptoExchange.Net.Sockets
             if (checkTime - _lastReceivedMessagesUpdate > TimeSpan.FromSeconds(1))
             {
                 foreach (var msg in _receivedMessages.ToList()) // To list here because we're removing from the list
-                {
                     if (checkTime - msg.Timestamp > TimeSpan.FromSeconds(3))
                         _receivedMessages.Remove(msg);
-                }
 
                 _lastReceivedMessagesUpdate = checkTime;
             }
@@ -708,52 +708,25 @@ namespace CryptoExchange.Net.Sockets
         /// <summary>
         /// Set proxy on socket
         /// </summary>
-        /// <param name="socket"></param>
         /// <param name="proxy"></param>
         /// <exception cref="ArgumentException"></exception>
-        protected virtual void SetProxy(ClientWebSocket socket, ApiProxy proxy)
+        protected virtual void SetProxy(ApiProxy proxy)
         {
             if (!Uri.TryCreate($"{proxy.Host}:{proxy.Port}", UriKind.Absolute, out var uri))
                 throw new ArgumentException("Proxy settings invalid, {proxy.Host}:{proxy.Port} not a valid URI", nameof(proxy));
 
-            socket.Options.Proxy = uri?.Scheme == null
-                ? socket.Options.Proxy = new WebProxy(proxy.Host, proxy.Port)
-                : socket.Options.Proxy = new WebProxy
+            _socket.Options.Proxy = uri?.Scheme == null
+                ? _socket.Options.Proxy = new WebProxy(proxy.Host, proxy.Port)
+                : _socket.Options.Proxy = new WebProxy
                 {
                     Address = uri
                 };
 
             if (proxy.Login != null)
-                socket.Options.Proxy.Credentials = new NetworkCredential(proxy.Login, proxy.Password);
+                _socket.Options.Proxy.Credentials = new NetworkCredential(proxy.Login, proxy.Password);
         }
     }
 
-    /// <summary>
-    /// Message info
-    /// </summary>
-    public struct SendItem
-    {
-        /// <summary>
-        /// The request id
-        /// </summary>
-        public int Id { get; set; }
-
-        /// <summary>
-        /// The request id
-        /// </summary>
-        public int Weight { get; set; }
-
-        /// <summary>
-        /// Timestamp the request was sent
-        /// </summary>
-        public DateTime SendTime { get; set; }
-
-        /// <summary>
-        /// The bytes to send
-        /// </summary>
-        public byte[] Bytes { get; set; }
-    }
-
     /// <summary>
     /// Received message info
     /// </summary>

CryptoExchange.Net/Sockets/DataEvent.cs

@@ -12,28 +12,20 @@ namespace CryptoExchange.Net.Sockets
         /// The timestamp the data was received
         /// </summary>
         public DateTime Timestamp { get; set; }
-
         /// <summary>
         /// The topic of the update, what symbol/asset etc..
         /// </summary>
         public string? Topic { get; set; }
-
         /// <summary>
         /// The original data that was received, only available when OutputOriginalData is set to true in the client options
         /// </summary>
         public string? OriginalData { get; set; }
-
         /// <summary>
         /// The received data deserialized into an object
         /// </summary>
         public T Data { get; set; }
 
-        /// <summary>
-        /// Ctor
-        /// </summary>
-        /// <param name="data"></param>
-        /// <param name="timestamp"></param>
-        public DataEvent(T data, DateTime timestamp)
+        internal DataEvent(T data, DateTime timestamp)
         {
             Data = data;
             Timestamp = timestamp;

CryptoExchange.Net/Sockets/MessageEvent.cs

@@ -12,17 +12,14 @@ namespace CryptoExchange.Net.Sockets
         /// The connection the message was received on
         /// </summary>
         public SocketConnection Connection { get; set; }
-
         /// <summary>
         /// The json object of the data
         /// </summary>
         public JToken JsonData { get; set; }
-
         /// <summary>
         /// The originally received string data
         /// </summary>
         public string? OriginalData { get; set; }
-
         /// <summary>
         /// The timestamp of when the data was received
         /// </summary>

CryptoExchange.Net/Sockets/PendingRequest.cs

@@ -7,45 +7,35 @@ namespace CryptoExchange.Net.Sockets
 {
     internal class PendingRequest
     {
-        public int Id { get; set; }
         public Func<JToken, bool> Handler { get; }
         public JToken? Result { get; private set; }
         public bool Completed { get; private set; }
         public AsyncResetEvent Event { get; }
-        public DateTime RequestTimestamp { get; set; }
         public TimeSpan Timeout { get; }
-        public SocketSubscription? Subscription { get; }
 
-        private CancellationTokenSource? _cts;
+        private CancellationTokenSource cts;
 
-        public PendingRequest(int id, Func<JToken, bool> handler, TimeSpan timeout, SocketSubscription? subscription)
+        public PendingRequest(Func<JToken, bool> handler, TimeSpan timeout)
         {
-            Id = id;
             Handler = handler;
             Event = new AsyncResetEvent(false, false);
             Timeout = timeout;
-            RequestTimestamp = DateTime.UtcNow;
-            Subscription = subscription;
-        }
 
-        public void IsSend()
-        {
-            // Start timeout countdown
-            _cts = new CancellationTokenSource(Timeout);
-            _cts.Token.Register(Fail, false);
+            cts = new CancellationTokenSource(timeout);
+            cts.Token.Register(Fail, false);
         }
 
         public bool CheckData(JToken data)
         {
-            return Handler(data);
-        }
+            if (Handler(data))
+            {
+                Result = data;
+                Completed = true;
+                Event.Set();
+                return true;
+            }
 
-        public bool Succeed(JToken data)
-        {
-            Result = data;
-            Completed = true;
-            Event.Set();
-            return true;
+            return false;
         }
 
         public void Fail()

CryptoExchange.Net/Sockets/SocketConnection.cs

@@ -4,6 +4,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Threading.Tasks;
+using CryptoExchange.Net.Logging;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Microsoft.Extensions.Logging;
@@ -52,8 +53,8 @@ namespace CryptoExchange.Net.Sockets
         /// </summary>
         public int SubscriptionCount
         {
-            get { lock (_subscriptionLock)
-                return _subscriptions.Count(h => h.UserSubscription); }
+            get { lock (subscriptionLock)
+                return subscriptions.Count(h => h.UserSubscription); }
         }
 
         /// <summary>
@@ -63,8 +64,8 @@ namespace CryptoExchange.Net.Sockets
         {
             get
             {
-                lock (_subscriptionLock)
-                    return _subscriptions.Where(h => h.UserSubscription).ToArray();
+                lock (subscriptionLock)
+                    return subscriptions.Where(h => h.UserSubscription).ToArray();
             }
         }
 
@@ -107,25 +108,20 @@ namespace CryptoExchange.Net.Sockets
         /// Tag for identificaion
         /// </summary>
         public string Tag { get; set; }
-        
-        /// <summary>
-        /// Additional properties for this connection
-        /// </summary>
-        public Dictionary<string, object> Properties { get; set; }
 
         /// <summary>
         /// If activity is paused
         /// </summary>
         public bool PausedActivity
         {
-            get => _pausedActivity;
+            get => pausedActivity;
             set
             {
-                if (_pausedActivity != value)
+                if (pausedActivity != value)
                 {
-                    _pausedActivity = value;
-                    _logger.Log(LogLevel.Information, $"Socket {SocketId} Paused activity: " + value);
-                    if(_pausedActivity) _ = Task.Run(() => ActivityPaused?.Invoke());
+                    pausedActivity = value;
+                    log.Write(LogLevel.Information, $"Socket {SocketId} Paused activity: " + value);
+                    if(pausedActivity) _ = Task.Run(() => ActivityPaused?.Invoke());
                     else _ = Task.Run(() => ActivityUnpaused?.Invoke());
                 }
             }
@@ -144,17 +140,18 @@ namespace CryptoExchange.Net.Sockets
 
                 var oldStatus = _status;
                 _status = value;
-                _logger.Log(LogLevel.Debug, $"Socket {SocketId} status changed from {oldStatus} to {_status}");
+                log.Write(LogLevel.Debug, $"Socket {SocketId} status changed from {oldStatus} to {_status}");
             }
         }
 
-        private bool _pausedActivity;
-        private readonly List<SocketSubscription> _subscriptions;
-        private readonly object _subscriptionLock = new();
+        private bool pausedActivity;
+        private readonly List<SocketSubscription> subscriptions;
+        private readonly object subscriptionLock = new();
 
-        private readonly ILogger _logger;
+        private readonly Log log;
+        private readonly BaseSocketClient socketClient;
 
-        private readonly List<PendingRequest> _pendingRequests;
+        private readonly List<PendingRequest> pendingRequests;
 
         private SocketStatus _status;
 
@@ -166,29 +163,27 @@ namespace CryptoExchange.Net.Sockets
         /// <summary>
         /// New socket connection
         /// </summary>
-        /// <param name="logger">The logger</param>
+        /// <param name="client">The socket client</param>
         /// <param name="apiClient">The api client</param>
         /// <param name="socket">The socket</param>
         /// <param name="tag"></param>
-        public SocketConnection(ILogger logger, SocketApiClient apiClient, IWebsocket socket, string tag)
+        public SocketConnection(BaseSocketClient client, SocketApiClient apiClient, IWebsocket socket, string tag)
         {
-            _logger = logger;
+            log = client.log;
+            socketClient = client;
             ApiClient = apiClient;
             Tag = tag;
-            Properties = new Dictionary<string, object>();
 
-            _pendingRequests = new List<PendingRequest>();
-            _subscriptions = new List<SocketSubscription>();
+            pendingRequests = new List<PendingRequest>();
+            subscriptions = new List<SocketSubscription>();
 
             _socket = socket;
             _socket.OnMessage += HandleMessage;
-            _socket.OnRequestSent += HandleRequestSent;
             _socket.OnOpen += HandleOpen;
             _socket.OnClose += HandleClose;
             _socket.OnReconnecting += HandleReconnecting;
             _socket.OnReconnected += HandleReconnected;
             _socket.OnError += HandleError;
-            _socket.GetReconnectionUrl = GetReconnectionUrlAsync;
         }
 
         /// <summary>
@@ -207,9 +202,9 @@ namespace CryptoExchange.Net.Sockets
         {
             Status = SocketStatus.Closed;
             Authenticated = false;
-            lock(_subscriptionLock)
+            lock(subscriptionLock)
             {
-                foreach (var sub in _subscriptions)
+                foreach (var sub in subscriptions)
                     sub.Confirmed = false;
             }    
             Task.Run(() => ConnectionClosed?.Invoke());
@@ -223,22 +218,12 @@ namespace CryptoExchange.Net.Sockets
             Status = SocketStatus.Reconnecting;
             DisconnectTime = DateTime.UtcNow;
             Authenticated = false;
-            lock (_subscriptionLock)
+            lock (subscriptionLock)
             {
-                foreach (var sub in _subscriptions)
+                foreach (var sub in subscriptions)
                     sub.Confirmed = false;
             }
-
-            _ = Task.Run(() => ConnectionLost?.Invoke());
-        }
-
-        /// <summary>
-        /// Get the url to connect to when reconnecting
-        /// </summary>
-        /// <returns></returns>
-        protected virtual async Task<Uri?> GetReconnectionUrlAsync()
-        {
-            return await ApiClient.GetReconnectUriAsync(this).ConfigureAwait(false);
+            Task.Run(() => ConnectionLost?.Invoke());
         }
 
         /// <summary>
@@ -247,21 +232,18 @@ namespace CryptoExchange.Net.Sockets
         protected virtual async void HandleReconnected()
         {
             Status = SocketStatus.Resubscribing;
-            lock (_pendingRequests)
+            lock (pendingRequests)
             {
-                foreach (var pendingRequest in _pendingRequests.ToList())
+                foreach (var pendingRequest in pendingRequests.ToList())
                 {
                     pendingRequest.Fail();
-                    _pendingRequests.Remove(pendingRequest);
+                    pendingRequests.Remove(pendingRequest);
                 }
             }
 
             var reconnectSuccessful = await ProcessReconnectAsync().ConfigureAwait(false);
             if (!reconnectSuccessful)
-            {
-                _logger.Log(LogLevel.Warning, $"Failed reconnect processing: {reconnectSuccessful.Error}, reconnecting again");
                 await _socket.ReconnectAsync().ConfigureAwait(false);
-            }
             else
             {
                 Status = SocketStatus.Connected;
@@ -280,28 +262,9 @@ namespace CryptoExchange.Net.Sockets
         protected virtual void HandleError(Exception e)
         {
             if (e is WebSocketException wse)
-                _logger.Log(LogLevel.Warning, $"Socket {SocketId} error: Websocket error code {wse.WebSocketErrorCode}, details: " + e.ToLogString());
+                log.Write(LogLevel.Warning, $"Socket {SocketId} error: Websocket error code {wse.WebSocketErrorCode}, details: " + e.ToLogString());
             else
-                _logger.Log(LogLevel.Warning, $"Socket {SocketId} error: " + e.ToLogString());
-        }
-
-        /// <summary>
-        /// Handler for whenever a request is sent over the websocket
-        /// </summary>
-        /// <param name="requestId">Id of the request sent</param>
-        protected virtual void HandleRequestSent(int requestId)
-        {
-            PendingRequest pendingRequest;
-            lock (_pendingRequests)
-                pendingRequest = _pendingRequests.SingleOrDefault(p => p.Id == requestId);
-
-            if (pendingRequest == null)
-            {
-                _logger.Log(LogLevel.Debug, $"Socket {SocketId} - msg {requestId} - message sent, but not pending");
-                return;
-            }
-
-            pendingRequest.IsSend();
+                log.Write(LogLevel.Warning, $"Socket {SocketId} error: " + e.ToLogString());
         }
 
         /// <summary>
@@ -311,14 +274,14 @@ namespace CryptoExchange.Net.Sockets
         protected virtual void HandleMessage(string data)
         {
             var timestamp = DateTime.UtcNow;
-            _logger.Log(LogLevel.Trace, $"Socket {SocketId} received data: " + data);
+            log.Write(LogLevel.Trace, $"Socket {SocketId} received data: " + data);
             if (string.IsNullOrEmpty(data)) return;
 
-            var tokenData = data.ToJToken(_logger);
+            var tokenData = data.ToJToken(log);
             if (tokenData == null)
             {
                 data = $"\"{data}\"";
-                tokenData = data.ToJToken(_logger);
+                tokenData = data.ToJToken(log);
                 if (tokenData == null)
                     return;
             }
@@ -327,12 +290,10 @@ namespace CryptoExchange.Net.Sockets
 
             // Remove any timed out requests
             PendingRequest[] requests;
-            lock (_pendingRequests)
+            lock (pendingRequests)
             {
-                // Remove only timed out requests after 5 minutes have passed so we can still process any 
-                // message coming in after the request timeout
-                _pendingRequests.RemoveAll(r => r.Completed && DateTime.UtcNow - r.RequestTimestamp > TimeSpan.FromMinutes(5));
-                requests = _pendingRequests.ToArray();
+                pendingRequests.RemoveAll(r => r.Completed);
+                requests = pendingRequests.ToArray();
             }
 
             // Check if this message is an answer on any pending requests
@@ -340,25 +301,10 @@ namespace CryptoExchange.Net.Sockets
             {
                 if (pendingRequest.CheckData(tokenData))
                 {
-                    lock (_pendingRequests)
-                        _pendingRequests.Remove(pendingRequest);
+                    lock (pendingRequests)
+                        pendingRequests.Remove(pendingRequest);
 
-                    if (pendingRequest.Completed)
-                    {
-                        // Answer to a timed out request, unsub if it is a subscription request
-                        if (pendingRequest.Subscription != null)
-                        {
-                            _logger.Log(LogLevel.Warning, "Received subscription info after request timed out; unsubscribing. Consider increasing the RequestTimeout");
-                            _ = ApiClient.UnsubscribeAsync(this, pendingRequest.Subscription).ConfigureAwait(false);
-                        }
-                    }
-                    else
-                    {
-                        _logger.Log(LogLevel.Trace, $"Socket {SocketId} - msg {pendingRequest.Id} - received data matched to pending request");
-                        pendingRequest.Succeed(tokenData);
-                    }
-
-                    if (!ApiClient.ContinueOnQueryResponse)
+                    if (!socketClient.ContinueOnQueryResponse)
                         return;
 
                     handledResponse = true;
@@ -367,23 +313,21 @@ namespace CryptoExchange.Net.Sockets
             }
 
             // Message was not a request response, check data handlers
-            var messageEvent = new MessageEvent(this, tokenData, ApiClient.OutputOriginalData ? data : null, timestamp);
+            var messageEvent = new MessageEvent(this, tokenData, socketClient.ClientOptions.OutputOriginalData ? data : null, timestamp);
             var (handled, userProcessTime, subscription) = HandleData(messageEvent);
             if (!handled && !handledResponse)
             {
-                if (!ApiClient.UnhandledMessageExpected)
-                    _logger.Log(LogLevel.Warning, $"Socket {SocketId} Message not handled: " + tokenData);
+                if (!socketClient.UnhandledMessageExpected)
+                    log.Write(LogLevel.Warning, $"Socket {SocketId} Message not handled: " + tokenData);
                 UnhandledMessage?.Invoke(tokenData);
             }
 
             var total = DateTime.UtcNow - timestamp;
             if (userProcessTime.TotalMilliseconds > 500)
-            {
-                _logger.Log(LogLevel.Debug, $"Socket {SocketId}{(subscription == null ? "" : " subscription " + subscription!.Id)} message processing slow ({(int)total.TotalMilliseconds}ms, {(int)userProcessTime.TotalMilliseconds}ms user code), consider offloading data handling to another thread. " +
+                log.Write(LogLevel.Debug, $"Socket {SocketId}{(subscription == null ? "" : " subscription " + subscription!.Id)} message processing slow ({(int)total.TotalMilliseconds}ms, {(int)userProcessTime.TotalMilliseconds}ms user code), consider offloading data handling to another thread. " +
                                                 "Data from this socket may arrive late or not at all if message processing is continuously slow.");
-            }
 
-            _logger.Log(LogLevel.Trace, $"Socket {SocketId}{(subscription == null ? "" : " subscription " + subscription!.Id)} message processed in {(int)total.TotalMilliseconds}ms ({(int)userProcessTime.TotalMilliseconds}ms user code)");
+            log.Write(LogLevel.Trace, $"Socket {SocketId}{(subscription == null ? "" : " subscription " + subscription!.Id)} message processed in {(int)total.TotalMilliseconds}ms, ({(int)userProcessTime.TotalMilliseconds}ms user code)");
         }
 
         /// <summary>
@@ -413,12 +357,12 @@ namespace CryptoExchange.Net.Sockets
             if (Status == SocketStatus.Closed || Status == SocketStatus.Disposed)
                 return;
 
-            if (ApiClient.socketConnections.ContainsKey(SocketId))
-                ApiClient.socketConnections.TryRemove(SocketId, out _);
+            if (socketClient.socketConnections.ContainsKey(SocketId))
+                socketClient.socketConnections.TryRemove(SocketId, out _);
 
-            lock (_subscriptionLock)
+            lock (subscriptionLock)
             {
-                foreach (var subscription in _subscriptions)
+                foreach (var subscription in subscriptions)
                 {
                     if (subscription.CancellationTokenRegistration.HasValue)
                         subscription.CancellationTokenRegistration.Value.Dispose();
@@ -436,46 +380,43 @@ namespace CryptoExchange.Net.Sockets
         /// <returns></returns>
         public async Task CloseAsync(SocketSubscription subscription)
         {
-            lock (_subscriptionLock)
+            lock (subscriptionLock)
             {
-                if (!_subscriptions.Contains(subscription))
+                if (!subscriptions.Contains(subscription))
                     return;
 
-                subscription.Closed = true;
+                subscriptions.Remove(subscription);
             }
 
             if (Status == SocketStatus.Closing || Status == SocketStatus.Closed || Status == SocketStatus.Disposed)
                 return;
 
-            _logger.Log(LogLevel.Debug, $"Socket {SocketId} closing subscription {subscription.Id}");
+            log.Write(LogLevel.Debug, $"Socket {SocketId} closing subscription {subscription.Id}");
             if (subscription.CancellationTokenRegistration.HasValue)
                 subscription.CancellationTokenRegistration.Value.Dispose();
 
             if (subscription.Confirmed && _socket.IsOpen)
-                await ApiClient.UnsubscribeAsync(this, subscription).ConfigureAwait(false);
+                await socketClient.UnsubscribeAsync(this, subscription).ConfigureAwait(false);
 
             bool shouldCloseConnection;
-            lock (_subscriptionLock)
+            lock (subscriptionLock)
             {
                 if (Status == SocketStatus.Closing)
                 {
-                    _logger.Log(LogLevel.Debug, $"Socket {SocketId} already closing");
+                    log.Write(LogLevel.Debug, $"Socket {SocketId} already closing");
                     return;
                 }
 
-                shouldCloseConnection = _subscriptions.All(r => !r.UserSubscription || r.Closed);
+                shouldCloseConnection = subscriptions.All(r => !r.UserSubscription);
                 if (shouldCloseConnection)
                     Status = SocketStatus.Closing;
             }
 
             if (shouldCloseConnection)
             {
-                _logger.Log(LogLevel.Debug, $"Socket {SocketId} closing as there are no more subscriptions");
+                log.Write(LogLevel.Debug, $"Socket {SocketId} closing as there are no more subscriptions");
                 await CloseAsync().ConfigureAwait(false);
             }
-
-            lock (_subscriptionLock)
-                _subscriptions.Remove(subscription);
         }
 
         /// <summary>
@@ -493,14 +434,14 @@ namespace CryptoExchange.Net.Sockets
         /// <param name="subscription"></param>
         public bool AddSubscription(SocketSubscription subscription)
         {
-            lock (_subscriptionLock)
+            lock (subscriptionLock)
             {
                 if (Status != SocketStatus.None && Status != SocketStatus.Connected)
                     return false;
 
-                _subscriptions.Add(subscription);
+                subscriptions.Add(subscription);
                 if(subscription.UserSubscription)
-                    _logger.Log(LogLevel.Debug, $"Socket {SocketId} adding new subscription with id {subscription.Id}, total subscriptions on connection: {_subscriptions.Count(s => s.UserSubscription)}");
+                    log.Write(LogLevel.Debug, $"Socket {SocketId} adding new subscription with id {subscription.Id}, total subscriptions on connection: {subscriptions.Count(s => s.UserSubscription)}");
                 return true;
             }
         }
@@ -511,8 +452,8 @@ namespace CryptoExchange.Net.Sockets
         /// <param name="id"></param>
         public SocketSubscription? GetSubscription(int id)
         {
-            lock (_subscriptionLock)
-                return _subscriptions.SingleOrDefault(s => s.Id == id);
+            lock (subscriptionLock)
+                return subscriptions.SingleOrDefault(s => s.Id == id);
         }
 
         /// <summary>
@@ -522,8 +463,8 @@ namespace CryptoExchange.Net.Sockets
         /// <returns></returns>
         public SocketSubscription? GetSubscriptionByRequest(Func<object?, bool> predicate)
         {
-            lock(_subscriptionLock)
-                return _subscriptions.SingleOrDefault(s => predicate(s.Request));
+            lock(subscriptionLock)
+                return subscriptions.SingleOrDefault(s => predicate(s.Request));
         }
 
         /// <summary>
@@ -541,15 +482,15 @@ namespace CryptoExchange.Net.Sockets
 
                 // Loop the subscriptions to check if any of them signal us that the message is for them
                 List<SocketSubscription> subscriptionsCopy;
-                lock (_subscriptionLock)
-                    subscriptionsCopy = _subscriptions.ToList();
+                lock (subscriptionLock)
+                    subscriptionsCopy = subscriptions.ToList();
 
                 foreach (var subscription in subscriptionsCopy)
                 {
                     currentSubscription = subscription;
                     if (subscription.Request == null)
                     {
-                        if (ApiClient.MessageMatchesHandler(this, messageEvent.JsonData, subscription.Identifier!))
+                        if (socketClient.MessageMatchesHandler(this, messageEvent.JsonData, subscription.Identifier!))
                         {
                             handled = true;
                             var userSw = Stopwatch.StartNew();
@@ -560,10 +501,10 @@ namespace CryptoExchange.Net.Sockets
                     }
                     else
                     {
-                        if (ApiClient.MessageMatchesHandler(this, messageEvent.JsonData, subscription.Request))
+                        if (socketClient.MessageMatchesHandler(this, messageEvent.JsonData, subscription.Request))
                         {
                             handled = true;
-                            messageEvent.JsonData = ApiClient.ProcessTokenData(messageEvent.JsonData);
+                            messageEvent.JsonData = socketClient.ProcessTokenData(messageEvent.JsonData);
                             var userSw = Stopwatch.StartNew();
                             subscription.MessageHandler(messageEvent);
                             userSw.Stop();
@@ -576,7 +517,7 @@ namespace CryptoExchange.Net.Sockets
             }
             catch (Exception ex)
             {
-                _logger.Log(LogLevel.Error, $"Socket {SocketId} Exception during message processing\r\nException: {ex.ToLogString()}\r\nData: {messageEvent.JsonData}");
+                log.Write(LogLevel.Error, $"Socket {SocketId} Exception during message processing\r\nException: {ex.ToLogString()}\r\nData: {messageEvent.JsonData}");
                 currentSubscription?.InvokeExceptionHandler(ex);
                 return (false, TimeSpan.Zero, null);
             }
@@ -588,71 +529,46 @@ namespace CryptoExchange.Net.Sockets
         /// <typeparam name="T">The data type expected in response</typeparam>
         /// <param name="obj">The object to send</param>
         /// <param name="timeout">The timeout for response</param>
-        /// <param name="subscription">Subscription if this is a subscribe request</param>
         /// <param name="handler">The response handler, should return true if the received JToken was the response to the request</param>
-        /// <param name="weight">The weight of the message</param>
         /// <returns></returns>
-        public virtual async Task SendAndWaitAsync<T>(T obj, TimeSpan timeout, SocketSubscription? subscription, int weight, Func<JToken, bool> handler)
+        public virtual Task SendAndWaitAsync<T>(T obj, TimeSpan timeout, Func<JToken, bool> handler)
         {
-            var pending = new PendingRequest(ExchangeHelpers.NextId(), handler, timeout, subscription);
-            lock (_pendingRequests)
+            var pending = new PendingRequest(handler, timeout);
+            lock (pendingRequests)
             {
-                _pendingRequests.Add(pending);
+                pendingRequests.Add(pending);
             }
+            var sendOk = Send(obj);
+            if(!sendOk)            
+                pending.Fail();            
 
-            var sendOk = Send(pending.Id, obj, weight);
-            if (!sendOk)
-            {
-                pending.Fail();
-                return;
-            }
-
-            while (true)
-            {
-                if(!_socket.IsOpen)
-                {
-                    pending.Fail();
-                    return;
-                }
-
-                if (pending.Completed)
-                    return;
-
-                await pending.Event.WaitAsync(TimeSpan.FromMilliseconds(500)).ConfigureAwait(false);
-
-                if (pending.Completed)
-                    return;
-            }
+            return pending.Event.WaitAsync(timeout);
         }
 
         /// <summary>
         /// Send data over the websocket connection
         /// </summary>
         /// <typeparam name="T">The type of the object to send</typeparam>
-        /// <param name="requestId">The request id</param>
         /// <param name="obj">The object to send</param>
         /// <param name="nullValueHandling">How null values should be serialized</param>
-        /// <param name="weight">The weight of the message</param>
-        public virtual bool Send<T>(int requestId, T obj, int weight, NullValueHandling nullValueHandling = NullValueHandling.Ignore)
+        public virtual bool Send<T>(T obj, NullValueHandling nullValueHandling = NullValueHandling.Ignore)
         {
             if(obj is string str)
-                return Send(requestId, str, weight);
+                return Send(str);
             else
-                return Send(requestId, JsonConvert.SerializeObject(obj, Formatting.None, new JsonSerializerSettings { NullValueHandling = nullValueHandling }), weight);
+                return Send(JsonConvert.SerializeObject(obj, Formatting.None, new JsonSerializerSettings { NullValueHandling = nullValueHandling }));
         }
 
         /// <summary>
         /// Send string data over the websocket connection
         /// </summary>
         /// <param name="data">The data to send</param>
-        /// <param name="weight">The weight of the message</param>
-        /// <param name="requestId">The id of the request</param>
-        public virtual bool Send(int requestId, string data, int weight)
+        public virtual bool Send(string data)
         {
-            _logger.Log(LogLevel.Trace, $"Socket {SocketId} - msg {requestId} - sending messsage: {data}");
+            log.Write(LogLevel.Trace, $"Socket {SocketId} sending data: {data}");
             try
             {
-                _socket.Send(requestId, data, weight);
+                _socket.Send(data);
                 return true;
             }
             catch(Exception)
@@ -667,40 +583,36 @@ namespace CryptoExchange.Net.Sockets
                 return new CallResult<bool>(new WebError("Socket not connected"));
 
             bool anySubscriptions = false;
-            lock (_subscriptionLock)
-                anySubscriptions = _subscriptions.Any(s => s.UserSubscription);
+            lock (subscriptionLock)
+                anySubscriptions = subscriptions.Any(s => s.UserSubscription);
 
             if (!anySubscriptions)
             {
                 // No need to resubscribe anything
-                _logger.Log(LogLevel.Debug, $"Socket {SocketId} Nothing to resubscribe, closing connection");
+                log.Write(LogLevel.Debug, $"Socket {SocketId} Nothing to resubscribe, closing connection");
                 _ = _socket.CloseAsync();
                 return new CallResult<bool>(true);
             }
 
-            bool anyAuthenticated = false;
-            lock (_subscriptionLock)
-                anyAuthenticated = _subscriptions.Any(s => s.Authenticated);
-
-            if (anyAuthenticated)
+            if (subscriptions.Any(s => s.Authenticated))
             {
                 // If we reconnected a authenticated connection we need to re-authenticate
-                var authResult = await ApiClient.AuthenticateSocketAsync(this).ConfigureAwait(false);
+                var authResult = await socketClient.AuthenticateSocketAsync(this).ConfigureAwait(false);
                 if (!authResult)
                 {
-                    _logger.Log(LogLevel.Warning, $"Socket {SocketId} authentication failed on reconnected socket. Disconnecting and reconnecting.");
+                    log.Write(LogLevel.Warning, $"Socket {SocketId} authentication failed on reconnected socket. Disconnecting and reconnecting.");
                     return authResult;
                 }
 
                 Authenticated = true;
-                _logger.Log(LogLevel.Debug, $"Socket {SocketId} authentication succeeded on reconnected socket.");
+                log.Write(LogLevel.Debug, $"Socket {SocketId} authentication succeeded on reconnected socket.");
             }
 
             // Get a list of all subscriptions on the socket
             List<SocketSubscription> subscriptionList = new List<SocketSubscription>();
-            lock (_subscriptionLock)
+            lock (subscriptionLock)
             {
-                foreach (var subscription in _subscriptions)
+                foreach (var subscription in subscriptions)
                 {
                     if (subscription.Request != null)
                         subscriptionList.Add(subscription);
@@ -709,25 +621,15 @@ namespace CryptoExchange.Net.Sockets
                 }
             }
 
-            foreach(var subscription in subscriptionList.Where(s => s.Request != null))
-            {
-                var result = await ApiClient.RevitalizeRequestAsync(subscription.Request!).ConfigureAwait(false);
-                if (!result)
-                {
-                    _logger.Log(LogLevel.Warning, "Failed request revitalization: " + result.Error);
-                    return result.As<bool>(false);
-                }
-            }
-
             // Foreach subscription which is subscribed by a subscription request we will need to resend that request to resubscribe
-            for (var i = 0; i < subscriptionList.Count; i += ApiClient.ClientOptions.MaxConcurrentResubscriptionsPerSocket)
+            for (var i = 0; i < subscriptionList.Count; i += socketClient.ClientOptions.MaxConcurrentResubscriptionsPerSocket)
             {
                 if (!_socket.IsOpen)
                     return new CallResult<bool>(new WebError("Socket not connected"));
 
                 var taskList = new List<Task<CallResult<bool>>>();
-                foreach (var subscription in subscriptionList.Skip(i).Take(ApiClient.ClientOptions.MaxConcurrentResubscriptionsPerSocket))
-                    taskList.Add(ApiClient.SubscribeAndWaitAsync(this, subscription.Request!, subscription));
+                foreach (var subscription in subscriptionList.Skip(i).Take(socketClient.ClientOptions.MaxConcurrentResubscriptionsPerSocket))
+                    taskList.Add(socketClient.SubscribeAndWaitAsync(this, subscription.Request!, subscription));
 
                 await Task.WhenAll(taskList).ConfigureAwait(false);
                 if (taskList.Any(t => !t.Result.Success))
@@ -740,13 +642,13 @@ namespace CryptoExchange.Net.Sockets
             if (!_socket.IsOpen)
                 return new CallResult<bool>(new WebError("Socket not connected"));
 
-            _logger.Log(LogLevel.Debug, $"Socket {SocketId} all subscription successfully resubscribed on reconnected socket.");
+            log.Write(LogLevel.Debug, $"Socket {SocketId} all subscription successfully resubscribed on reconnected socket.");
             return new CallResult<bool>(true);
         }
 
         internal async Task UnsubscribeAsync(SocketSubscription socketSubscription)
         {
-            await ApiClient.UnsubscribeAsync(this, socketSubscription).ConfigureAwait(false);
+            await socketClient.UnsubscribeAsync(this, socketSubscription).ConfigureAwait(false);
         }
 
         internal async Task<CallResult<bool>> ResubscribeAsync(SocketSubscription socketSubscription)
@@ -754,7 +656,7 @@ namespace CryptoExchange.Net.Sockets
             if (!_socket.IsOpen)
                 return new CallResult<bool>(new UnknownError("Socket is not connected"));
 
-            return await ApiClient.SubscribeAndWaitAsync(this, socketSubscription.Request!, socketSubscription).ConfigureAwait(false);
+            return await socketClient.SubscribeAndWaitAsync(this, socketSubscription.Request!, socketSubscription).ConfigureAwait(false);
         }
 
         /// <summary>

CryptoExchange.Net/Sockets/SocketSubscription.cs

@@ -48,11 +48,6 @@ namespace CryptoExchange.Net.Sockets
         /// </summary>
         public bool Authenticated { get; set; }
 
-        /// <summary>
-        /// Whether we're closing this subscription and a socket connection shouldn't be kept open for it
-        /// </summary>
-        public bool Closed { get; set; }
-
         /// <summary>
         /// Cancellation token registration, should be disposed when subscription is closed. Used for closing the subscription with 
         /// a provided cancelation token

CryptoExchange.Net/Sockets/UpdateSubscription.cs

@@ -9,16 +9,16 @@ namespace CryptoExchange.Net.Sockets
     /// </summary>
     public class UpdateSubscription
     {
-        private readonly SocketConnection _connection;
-        private readonly SocketSubscription _subscription;
+        private readonly SocketConnection connection;
+        private readonly SocketSubscription subscription;
 
         /// <summary>
         /// Event when the connection is lost. The socket will automatically reconnect when possible.
         /// </summary>
         public event Action ConnectionLost
         {
-            add => _connection.ConnectionLost += value;
-            remove => _connection.ConnectionLost -= value;
+            add => connection.ConnectionLost += value;
+            remove => connection.ConnectionLost -= value;
         }
 
         /// <summary>
@@ -26,8 +26,8 @@ namespace CryptoExchange.Net.Sockets
         /// </summary>
         public event Action ConnectionClosed
         {
-            add => _connection.ConnectionClosed += value;
-            remove => _connection.ConnectionClosed -= value;
+            add => connection.ConnectionClosed += value;
+            remove => connection.ConnectionClosed -= value;
         }
 
         /// <summary>
@@ -37,8 +37,8 @@ namespace CryptoExchange.Net.Sockets
         /// </summary>
         public event Action<TimeSpan> ConnectionRestored
         {
-            add => _connection.ConnectionRestored += value;
-            remove => _connection.ConnectionRestored -= value;
+            add => connection.ConnectionRestored += value;
+            remove => connection.ConnectionRestored -= value;
         }
 
         /// <summary>
@@ -46,8 +46,8 @@ namespace CryptoExchange.Net.Sockets
         /// </summary>
         public event Action ActivityPaused
         {
-            add => _connection.ActivityPaused += value;
-            remove => _connection.ActivityPaused -= value;
+            add => connection.ActivityPaused += value;
+            remove => connection.ActivityPaused -= value;
         }
 
         /// <summary>
@@ -55,8 +55,8 @@ namespace CryptoExchange.Net.Sockets
         /// </summary>
         public event Action ActivityUnpaused
         {
-            add => _connection.ActivityUnpaused += value;
-            remove => _connection.ActivityUnpaused -= value;
+            add => connection.ActivityUnpaused += value;
+            remove => connection.ActivityUnpaused -= value;
         }
 
         /// <summary>
@@ -64,19 +64,19 @@ namespace CryptoExchange.Net.Sockets
         /// </summary>
         public event Action<Exception> Exception
         {
-            add => _subscription.Exception += value;
-            remove => _subscription.Exception -= value;
+            add => subscription.Exception += value;
+            remove => subscription.Exception -= value;
         }
 
         /// <summary>
         /// The id of the socket
         /// </summary>
-        public int SocketId => _connection.SocketId;
+        public int SocketId => connection.SocketId;
 
         /// <summary>
         /// The id of the subscription
         /// </summary>
-        public int Id => _subscription.Id;
+        public int Id => subscription.Id;
 
         /// <summary>
         /// ctor
@@ -85,8 +85,8 @@ namespace CryptoExchange.Net.Sockets
         /// <param name="subscription">The subscription</param>
         public UpdateSubscription(SocketConnection connection, SocketSubscription subscription)
         {
-            this._connection = connection;
-            this._subscription = subscription;
+            this.connection = connection;
+            this.subscription = subscription;
         }
         
         /// <summary>
@@ -95,7 +95,7 @@ namespace CryptoExchange.Net.Sockets
         /// <returns></returns>
         public Task CloseAsync()
         {
-            return _connection.CloseAsync(_subscription);
+            return connection.CloseAsync(subscription);
         }
 
         /// <summary>
@@ -104,7 +104,7 @@ namespace CryptoExchange.Net.Sockets
         /// <returns></returns>
         public Task ReconnectAsync()
         {
-            return _connection.TriggerReconnectAsync();
+            return connection.TriggerReconnectAsync();
         }
 
         /// <summary>
@@ -113,7 +113,7 @@ namespace CryptoExchange.Net.Sockets
         /// <returns></returns>
         internal async Task UnsubscribeAsync()
         {
-            await _connection.UnsubscribeAsync(_subscription).ConfigureAwait(false);
+            await connection.UnsubscribeAsync(subscription).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -122,7 +122,7 @@ namespace CryptoExchange.Net.Sockets
         /// <returns></returns>
         internal async Task<CallResult<bool>> ResubscribeAsync()
         {
-            return await _connection.ResubscribeAsync(_subscription).ConfigureAwait(false);
+            return await connection.ResubscribeAsync(subscription).ConfigureAwait(false);
         }
     }
 }

CryptoExchange.Net/Sockets/WebSocketParameters.cs

@@ -1,9 +1,7 @@
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects;
 using System;
 using System.Collections.Generic;
 using System.Text;
-using System.Threading.Tasks;
 
 namespace CryptoExchange.Net.Sockets
 {
@@ -16,52 +14,42 @@ namespace CryptoExchange.Net.Sockets
         /// The uri to connect to
         /// </summary>
         public Uri Uri { get; set; }
-
         /// <summary>
         /// Headers to send in the connection handshake
         /// </summary>
         public IDictionary<string, string> Headers { get; set; } = new Dictionary<string, string>();
-
         /// <summary>
         /// Cookies to send in the connection handshake
         /// </summary>
         public IDictionary<string, string> Cookies { get; set; } = new Dictionary<string, string>();
-
         /// <summary>
         /// The time to wait between reconnect attempts
         /// </summary>
         public TimeSpan ReconnectInterval { get; set; } = TimeSpan.FromSeconds(5);
-
         /// <summary>
         /// Proxy for the connection
         /// </summary>
         public ApiProxy? Proxy { get; set; }
-
         /// <summary>
         /// Whether the socket should automatically reconnect when connection is lost
         /// </summary>
         public bool AutoReconnect { get; set; }
-
         /// <summary>
         /// The maximum time of no data received before considering the connection lost and closting/reconnecting the socket
         /// </summary>
         public TimeSpan? Timeout { get; set; }
-
         /// <summary>
         /// Interval at which to send ping frames
         /// </summary>
         public TimeSpan? KeepAliveInterval { get; set; }
-
         /// <summary>
-        /// The rate limiters for the socket connection
+        /// The max amount of messages to send per second
         /// </summary>
-        public IEnumerable<IRateLimiter>? RateLimiters { get; set; }
-
+        public int? RatelimitPerSecond { get; set; }
         /// <summary>
         /// Origin header value to send in the connection handshake
         /// </summary>
         public string? Origin { get; set; }
-
         /// <summary>
         /// Delegate used for processing byte data received from socket connections before it is processed by handlers
         /// </summary>

CryptoExchange.Net/Sockets/WebsocketFactory.cs

@@ -1,5 +1,5 @@
 using CryptoExchange.Net.Interfaces;
-using Microsoft.Extensions.Logging;
+using CryptoExchange.Net.Logging;
 
 namespace CryptoExchange.Net.Sockets
 {
@@ -9,9 +9,9 @@ namespace CryptoExchange.Net.Sockets
     public class WebsocketFactory : IWebsocketFactory
     {
         /// <inheritdoc />
-        public IWebsocket CreateWebsocket(ILogger logger, WebSocketParameters parameters)
+        public IWebsocket CreateWebsocket(Log log, WebSocketParameters parameters)
         {
-            return new CryptoExchangeWebSocketClient(logger, parameters);
+            return new CryptoExchangeWebSocketClient(log, parameters);
         }
     }
 }

Examples/BlazorClient/BlazorClient.csproj

@@ -5,15 +5,20 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Binance.Net" Version="9.0.1" />
-    <PackageReference Include="Bitfinex.Net" Version="6.0.0" />
-    <PackageReference Include="Bittrex.Net" Version="8.0.0" />
-    <PackageReference Include="Bybit.Net" Version="3.0.0" />
-    <PackageReference Include="CoinEx.Net" Version="6.0.0" />
-    <PackageReference Include="Huobi.Net" Version="5.0.0" />
-    <PackageReference Include="KrakenExchange.Net" Version="4.0.0" />
-    <PackageReference Include="Kucoin.Net" Version="5.0.0" />
-    <PackageReference Include="Serilog.AspNetCore" Version="6.0.0" />
+    <PackageReference Include="Binance.Net" Version="8.0.6" />
+    <PackageReference Include="Bitfinex.Net" Version="5.0.3" />
+    <PackageReference Include="Bittrex.Net" Version="7.0.4" />
+    <PackageReference Include="Bybit.Net" Version="0.0.4" />
+    <PackageReference Include="CoinEx.Net" Version="5.0.3" />
+    <PackageReference Include="FTX.Net" Version="1.0.4" />
+    <PackageReference Include="Huobi.Net" Version="4.0.4" />
+    <PackageReference Include="KrakenExchange.Net" Version="3.0.3" />
+    <PackageReference Include="Kucoin.Net" Version="4.0.3" />
+    <PackageReference Include="Serilog.AspNetCore" Version="4.1.1-dev-00250" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Data\" />
   </ItemGroup>
 
 </Project>

Examples/BlazorClient/Pages/Index.razor

@@ -1,12 +1,13 @@
 @page "/"
-@inject IBinanceRestClient binanceClient
-@inject IBitfinexRestClient bitfinexClient
-@inject IBittrexRestClient bittrexClient
-@inject IBybitRestClient bybitClient
-@inject ICoinExRestClient coinexClient
-@inject IHuobiRestClient huobiClient
-@inject IKrakenRestClient krakenClient
-@inject IKucoinRestClient kucoinClient
+@inject IBinanceClient binanceClient
+@inject IBitfinexClient bitfinexClient
+@inject IBittrexClient bittrexClient
+@inject IBybitClient bybitClient
+@inject ICoinExClient coinexClient
+@inject IFTXClient ftxClient
+@inject IHuobiClient huobiClient
+@inject IKrakenClient krakenClient
+@inject IKucoinClient kucoinClient
 
 <h3>BTC-USD prices:</h3>
 @foreach(var price in _prices.OrderBy(p => p.Key))
@@ -22,13 +23,14 @@
         var binanceTask = binanceClient.SpotApi.ExchangeData.GetTickerAsync("BTCUSDT");
         var bitfinexTask = bitfinexClient.SpotApi.ExchangeData.GetTickerAsync("tBTCUSD");
         var bittrexTask = bittrexClient.SpotApi.ExchangeData.GetTickerAsync("BTC-USDT");
-        var bybitTask = bybitClient.V5Api.ExchangeData.GetSpotTickersAsync("BTCUSDT");
+        var bybitTask = bybitClient.SpotApi.ExchangeData.GetTickerAsync("BTCUSDT");
         var coinexTask = coinexClient.SpotApi.ExchangeData.GetTickerAsync("BTCUSDT");
+        var ftxTask = ftxClient.TradeApi.ExchangeData.GetSymbolAsync("BTC/USD");
         var huobiTask = huobiClient.SpotApi.ExchangeData.GetTickerAsync("btcusdt");
         var krakenTask = krakenClient.SpotApi.ExchangeData.GetTickerAsync("XBTUSD");
         var kucoinTask =  kucoinClient.SpotApi.ExchangeData.GetTickerAsync("BTC-USDT");
 
-        await Task.WhenAll(binanceTask, bitfinexTask, bittrexTask, bybitTask, coinexTask, huobiTask, krakenTask, kucoinTask);
+        await Task.WhenAll(binanceTask, bitfinexTask, bittrexTask, bybitTask, coinexTask, ftxTask, huobiTask, krakenTask, kucoinTask);
 
         if (binanceTask.Result.Success)
             _prices.Add("Binance", binanceTask.Result.Data.LastPrice);
@@ -40,11 +42,14 @@
             _prices.Add("Bittrex", bittrexTask.Result.Data.LastPrice);
 
         if (bybitTask.Result.Success)
-            _prices.Add("Bybit", bybitTask.Result.Data.List.First().LastPrice);
+            _prices.Add("Bybit", bybitTask.Result.Data.LastPrice);
 
         if (coinexTask.Result.Success)
             _prices.Add("CoinEx", coinexTask.Result.Data.Ticker.LastPrice);
 
+        if (ftxTask.Result.Success)
+            _prices.Add("FTX", ftxTask.Result.Data.LastPrice ?? 0);
+
         if (huobiTask.Result.Success)
             _prices.Add("Huobi", huobiTask.Result.Data.ClosePrice ?? 0);
 

Examples/BlazorClient/Pages/LiveData.razor

@@ -4,12 +4,21 @@
 @inject IBittrexSocketClient bittrexSocketClient
 @inject IBybitSocketClient bybitSocketClient
 @inject ICoinExSocketClient coinExSocketClient
+@inject IFTXSocketClient ftxSocketClient
 @inject IHuobiSocketClient huobiSocketClient
 @inject IKrakenSocketClient krakenSocketClient
 @inject IKucoinSocketClient kucoinSocketClient
-@using System.Collections.Concurrent
+@using Binance.Net.Clients.SpotApi
+@using Bitfinex.Net.Clients.SpotApi
+@using Bittrex.Net.Clients.SpotApi
+@using Bybit.Net.Clients.SpotApi
+@using CoinEx.Net.Clients.SpotApi
 @using CryptoExchange.Net.Objects
 @using CryptoExchange.Net.Sockets
+@using Huobi.Net.Clients.SpotApi
+@using Kraken.Net.Clients.SpotApi
+@using Kucoin.Net.Clients.SpotApi
+@using System.Collections.Concurrent
 @implements IDisposable
 
 <h3>ETH-BTC prices, live updates:</h3>
@@ -26,14 +35,15 @@
     {
         var tasks = new Task<CallResult<UpdateSubscription>>[]
         {
-            binanceSocketClient.SpotApi.ExchangeData.SubscribeToTickerUpdatesAsync("ETHBTC", data => UpdateData("Binance", data.Data.LastPrice)),
-            bitfinexSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("tETHBTC", data => UpdateData("Bitfinex", data.Data.LastPrice)),
-            bittrexSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ETH-BTC", data => UpdateData("Bittrex", data.Data.LastPrice)),
-            bybitSocketClient.V5SpotApi.SubscribeToTickerUpdatesAsync("ETHBTC", data => UpdateData("Bybit", data.Data.LastPrice)),
-            coinExSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ETHBTC", data => UpdateData("CoinEx", data.Data.LastPrice)),
-            huobiSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ethbtc", data => UpdateData("Huobi", data.Data.ClosePrice ?? 0)),
-            krakenSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ETH/XBT", data => UpdateData("Kraken", data.Data.LastTrade.Price)),
-            kucoinSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ETH-BTC", data => UpdateData("Kucoin", data.Data.LastPrice ?? 0)),
+            binanceSocketClient.SpotStreams.SubscribeToTickerUpdatesAsync("ETHBTC", data => UpdateData("Binance", data.Data.LastPrice)),
+            bitfinexSocketClient.SpotStreams.SubscribeToTickerUpdatesAsync("tETHBTC", data => UpdateData("Bitfinex", data.Data.LastPrice)),
+            bittrexSocketClient.SpotStreams.SubscribeToTickerUpdatesAsync("ETH-BTC", data => UpdateData("Bittrex", data.Data.LastPrice)),
+            bybitSocketClient.SpotStreams.SubscribeToTickerUpdatesAsync("ETHBTC", data => UpdateData("Bybit", data.Data.LastPrice)),
+            coinExSocketClient.SpotStreams.SubscribeToTickerUpdatesAsync("ETHBTC", data => UpdateData("CoinEx", data.Data.LastPrice)),
+            ftxSocketClient.Streams.SubscribeToTickerUpdatesAsync("ETH/BTC", data => UpdateData("FTX", data.Data.LastPrice ?? 0)),
+            huobiSocketClient.SpotStreams.SubscribeToTickerUpdatesAsync("ethbtc", data => UpdateData("Huobi", data.Data.ClosePrice ?? 0)),
+            krakenSocketClient.SpotStreams.SubscribeToTickerUpdatesAsync("ETH/XBT", data => UpdateData("Kraken", data.Data.LastTrade.Price)),
+            kucoinSocketClient.SpotStreams.SubscribeToTickerUpdatesAsync("ETH-BTC", data => UpdateData("Kucoin", data.Data.LastPrice ?? 0)),
         };
 
         await Task.WhenAll(tasks);

Examples/BlazorClient/Pages/OrderBooks.razor

@@ -1,24 +1,19 @@
 @page "/OrderBooks"
+@using Binance.Net.SymbolOrderBooks
+@using Bitfinex.Net.SymbolOrderBooks
+@using Bittrex.Net.SymbolOrderBooks
+@using Bybit.Net.SymbolOrderBooks
+@using CryptoExchange.Net.Interfaces
+@using CryptoExchange.Net.Objects
+@using CryptoExchange.Net.Sockets
+@using CoinEx.Net.SymbolOrderBooks
+@using FTX.Net.SymbolOrderBooks
+@using Huobi.Net.SymbolOrderBooks
+@using Kraken.Net.SymbolOrderBooks
+@using Kucoin.Net.Clients
+@using Kucoin.Net.SymbolOrderBooks
 @using System.Collections.Concurrent
 @using System.Timers
-@using Binance.Net.Interfaces
-@using Bitfinex.Net.Interfaces
-@using Bittrex.Net.Interfaces
-@using Bybit.Net.Interfaces
-@using CoinEx.Net.Interfaces
-@using CryptoExchange.Net.Interfaces
-@using Huobi.Net.Interfaces
-@using Kraken.Net.Interfaces
-@using Kucoin.Net.Clients
-@using Kucoin.Net.Interfaces
-@inject IBinanceOrderBookFactory binanceFactory
-@inject IBitfinexOrderBookFactory bitfinexFactory
-@inject IBittrexOrderBookFactory bittrexFactory
-@inject IBybitOrderBookFactory bybitFactory
-@inject ICoinExOrderBookFactory coinExFactory
-@inject IHuobiOrderBookFactory huobiFactory
-@inject IKrakenOrderBookFactory krakenFactory
-@inject IKucoinOrderBookFactory kucoinFactory
 @implements IDisposable
 
 <h3>ETH-BTC books, live updates:</h3>
@@ -45,21 +40,22 @@
     protected override async Task OnInitializedAsync()
     {
         // Since the Kucoin order book stream needs authentication we will need to provide API credentials beforehand
-        KucoinRestClient.SetDefaultOptions(options =>
-        {
-            options.ApiCredentials = new Kucoin.Net.Objects.KucoinApiCredentials("KEY", "SECRET", "PASSPHRASE");
-        });
+        KucoinClient.SetDefaultOptions(new Kucoin.Net.Objects.KucoinClientOptions
+            {
+                ApiCredentials = new Kucoin.Net.Objects.KucoinApiCredentials("KEY", "SECRET", "PASSPHRASE")
+            });
 
         _books = new Dictionary<string, ISymbolOrderBook>
             {
-                { "Binance", binanceFactory.CreateSpot("ETHBTC") },
-                { "Bitfinex", bitfinexFactory.Create("tETHBTC") },
-                { "Bittrex", bittrexFactory.Create("ETH-BTC") },
-                { "Bybit", bybitFactory.Create("ETHBTC", Bybit.Net.Enums.Category.Spot) },
-                { "CoinEx", coinExFactory.CreateSpot("ETHBTC") },
-                { "Huobi", huobiFactory.CreateSpot("ethbtc") },
-                { "Kraken", krakenFactory.CreateSpot("ETH/XBT") },
-                { "Kucoin", kucoinFactory.CreateSpot("ETH-BTC") },
+                { "Binance", new BinanceSpotSymbolOrderBook("ETHBTC") },
+                { "Bitfinex", new BitfinexSymbolOrderBook("tETHBTC") },
+                { "Bittrex", new BittrexSymbolOrderBook("ETH-BTC") },
+                { "Bybit", new BybitSpotSymbolOrderBook("ETHBTC") },
+                { "CoinEx", new CoinExSpotSymbolOrderBook("ETHBTC") },
+                { "FTX", new FTXSymbolOrderBook("ETH/BTC") },
+                { "Huobi", new HuobiSpotSymbolOrderBook("ethbtc") },
+                { "Kraken", new KrakenSpotSymbolOrderBook("ETH/XBT") },
+                { "Kucoin", new KucoinSpotSymbolOrderBook("ETH-BTC") },
             };
 
         await Task.WhenAll(_books.Select(b => b.Value.StartAsync()));
@@ -74,7 +70,7 @@
     {
         _timer.Stop();
         _timer.Dispose();
-        foreach (var book in _books.Where(b => b.Value.Status != CryptoExchange.Net.Objects.OrderBookStatus.Disconnected))
+        foreach (var book in _books)
             // It's not necessary to wait for this
             _ = book.Value.StopAsync();
     }

Examples/BlazorClient/Pages/SpotClient.razor

@@ -1,12 +1,13 @@
 @page "/SpotClient"
-@inject IBinanceRestClient binanceClient
-@inject IBitfinexRestClient bitfinexClient
-@inject IBittrexRestClient bittrexClient
-@inject IBybitRestClient bybitClient
-@inject ICoinExRestClient coinexClient
-@inject IHuobiRestClient huobiClient
-@inject IKrakenRestClient krakenClient
-@inject IKucoinRestClient kucoinClient
+@inject IBinanceClient binanceClient
+@inject IBitfinexClient bitfinexClient
+@inject IBittrexClient bittrexClient
+@inject IBybitClient bybitClient
+@inject ICoinExClient coinexClient
+@inject IFTXClient ftxClient
+@inject IHuobiClient huobiClient
+@inject IKrakenClient krakenClient
+@inject IKucoinClient kucoinClient
 @using Binance.Net.Clients.SpotApi
 @using Bitfinex.Net.Clients.SpotApi
 @using Bittrex.Net.Clients.SpotApi
@@ -14,6 +15,7 @@
 @using CoinEx.Net.Clients.SpotApi
 @using CryptoExchange.Net.Interfaces
 @using CryptoExchange.Net.Interfaces.CommonClients
+@using FTX.Net.Clients.TradeApi
 @using Huobi.Net.Clients.SpotApi
 @using Kraken.Net.Clients.SpotApi
 @using Kucoin.Net.Clients.SpotApi
@@ -35,8 +37,9 @@
                 binanceClient.SpotApi.CommonSpotClient, 
                 bitfinexClient.SpotApi.CommonSpotClient,
                 bittrexClient.SpotApi.CommonSpotClient, 
-                bybitClient.SpotApiV1.CommonSpotClient, 
-                coinexClient.SpotApi.CommonSpotClient,
+                bybitClient.SpotApi.CommonSpotClient, 
+                coinexClient.SpotApi.CommonSpotClient, 
+                ftxClient.TradeApi.CommonSpotClient, 
                 huobiClient.SpotApi.CommonSpotClient, 
                 krakenClient.SpotApi.CommonSpotClient, 
                 kucoinClient.SpotApi.CommonSpotClient

Examples/BlazorClient/Startup.cs

@@ -2,11 +2,15 @@ using System.Collections.Generic;
 using Binance.Net;
 using Binance.Net.Clients;
 using Binance.Net.Interfaces.Clients;
+using Binance.Net.Objects;
 using Bitfinex.Net;
 using Bittrex.Net;
 using Bybit.Net;
 using CoinEx.Net;
+using CoinEx.Net.Clients;
+using CoinEx.Net.Interfaces.Clients;
 using CryptoExchange.Net.Authentication;
+using FTX.Net;
 using Huobi.Net;
 using Kraken.Net;
 using Kucoin.Net;
@@ -39,18 +43,35 @@ namespace BlazorClient
             services.AddServerSideBlazor();
 
             // Register the clients, options can be provided in the callback parameter
-            services.AddBinance(restOptions =>
-            {
-                restOptions.ApiCredentials = new ApiCredentials("KEY", "SECRET");
-            }, socketOptions =>
-            {
-                socketOptions.ApiCredentials = new ApiCredentials("KEY", "SECRET");
+            services.AddBinance((restClientOptions, socketClientOptions) => {
+                restClientOptions.ApiCredentials = new ApiCredentials("KEY", "SECRET");
+                restClientOptions.LogLevel = LogLevel.Trace;
+
+                // Point the logging to use the ILogger configuration, which uses Serilog here
+                restClientOptions.LogWriters = new List<ILogger> { _loggerFactory.CreateLogger<IBinanceClient>() };
+
+                socketClientOptions.ApiCredentials = new ApiCredentials("KEY", "SECRET");
             });
 
+            BinanceClient.SetDefaultOptions(new BinanceClientOptions
+            {
+                ApiCredentials = new ApiCredentials("KEY", "SECRET"),
+                LogLevel = LogLevel.Trace
+            });
+
+            BinanceSocketClient.SetDefaultOptions(new BinanceSocketClientOptions
+            {
+                ApiCredentials = new ApiCredentials("KEY", "SECRET"),
+            });
+
+            services.AddTransient<IBinanceClient, BinanceClient>();
+            services.AddScoped<IBinanceSocketClient, BinanceSocketClient>();
+
             services.AddBitfinex();
             services.AddBittrex();
             services.AddBybit();
             services.AddCoinEx();
+            services.AddFTX();
             services.AddHuobi();
             services.AddKraken();
             services.AddKucoin();

Examples/BlazorClient/_Imports.razor

@@ -13,6 +13,7 @@
 @using Bittrex.Net.Interfaces.Clients;
 @using Bybit.Net.Interfaces.Clients;
 @using CoinEx.Net.Interfaces.Clients;
+@using FTX.Net.Interfaces.Clients;
 @using Huobi.Net.Interfaces.Clients;
 @using Kraken.Net.Interfaces.Clients;
 @using Kucoin.Net.Interfaces.Clients;

Examples/ConsoleClient/ConsoleClient.csproj

@@ -6,14 +6,15 @@
   </PropertyGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Binance.Net" Version="9.0.1" />
-	<PackageReference Include="Bitfinex.Net" Version="6.0.0" />
-	<PackageReference Include="Bittrex.Net" Version="8.0.0" />
-	<PackageReference Include="Bybit.Net" Version="3.0.0" />
-	<PackageReference Include="CoinEx.Net" Version="6.0.0" />
-	<PackageReference Include="Huobi.Net" Version="5.0.0" />
-	<PackageReference Include="KrakenExchange.Net" Version="4.0.0" />
-		<PackageReference Include="Kucoin.Net" Version="5.0.0" />
+		<PackageReference Include="Binance.Net" Version="8.0.6" />
+	<PackageReference Include="Bitfinex.Net" Version="5.0.3" />
+	<PackageReference Include="Bittrex.Net" Version="7.0.4" />
+	<PackageReference Include="Bybit.Net" Version="0.0.4" />
+	<PackageReference Include="CoinEx.Net" Version="5.0.3" />
+	<PackageReference Include="FTX.Net" Version="1.0.4" />
+	<PackageReference Include="Huobi.Net" Version="4.0.4" />
+	<PackageReference Include="KrakenExchange.Net" Version="3.0.3" />
+		<PackageReference Include="Kucoin.Net" Version="4.0.3" />
 	</ItemGroup>
 
 </Project>

Examples/ConsoleClient/Exchanges/BinanceExchange.cs

@@ -17,21 +17,21 @@ namespace ConsoleClient.Exchanges
 
         public async Task<WebCallResult> CancelOrder(string symbol, string id)
         {
-            using var client = new BinanceRestClient();
+            using var client = new BinanceClient();
             var result = await client.SpotApi.Trading.CancelOrderAsync(symbol, long.Parse(id));
             return result.AsDataless();
         }
 
         public async Task<Dictionary<string, decimal>> GetBalances()
         {
-            using var client = new BinanceRestClient();
+            using var client = new BinanceClient();
             var result = await client.SpotApi.Account.GetAccountInfoAsync();
             return result.Data.Balances.ToDictionary(b => b.Asset, b => b.Total);
         }
 
         public async Task<IEnumerable<OpenOrder>> GetOpenOrders()
         {
-            using var client = new BinanceRestClient();
+            using var client = new BinanceClient();
             var result = await client.SpotApi.Trading.GetOpenOrdersAsync();
             // Should check result success status here
             return result.Data.Select(o => new OpenOrder
@@ -49,7 +49,7 @@ namespace ConsoleClient.Exchanges
 
         public async Task<decimal> GetPrice(string symbol)
         {
-            using var client = new BinanceRestClient();
+            using var client = new BinanceClient();
             var result = await client.SpotApi.ExchangeData.GetPriceAsync(symbol);
             // Should check result success status here
             return result.Data.Price;
@@ -57,7 +57,7 @@ namespace ConsoleClient.Exchanges
 
         public async Task<WebCallResult<string>> PlaceOrder(string symbol, string side, string type, decimal quantity, decimal? price)
         {
-            using var client = new BinanceRestClient();
+            using var client = new BinanceClient();
             var result = await client.SpotApi.Trading.PlaceOrderAsync(
                 symbol,
                 side.ToLower() == "buy" ? Binance.Net.Enums.OrderSide.Buy: Binance.Net.Enums.OrderSide.Sell, 
@@ -70,7 +70,7 @@ namespace ConsoleClient.Exchanges
 
         public async Task<UpdateSubscription> SubscribePrice(string symbol, Action<decimal> handler)
         {
-            var sub = await _socketClient.SpotApi.ExchangeData.SubscribeToMiniTickerUpdatesAsync(symbol, data => handler(data.Data.LastPrice));
+            var sub = await _socketClient.SpotStreams.SubscribeToMiniTickerUpdatesAsync(symbol, data => handler(data.Data.LastPrice));
             return sub.Data;
         }
     }

Examples/ConsoleClient/Exchanges/BybitExchange.cs

@@ -1,75 +0,0 @@
-using Bybit.Net.Clients;
-using Bybit.Net.Interfaces.Clients;
-using ConsoleClient.Models;
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Sockets;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace ConsoleClient.Exchanges
-{
-    internal class BybitExchange : IExchange
-    {
-        private IBybitSocketClient _socketClient = new BybitSocketClient();
-
-        public async Task<WebCallResult> CancelOrder(string symbol, string id)
-        {
-            using var client = new BybitRestClient();
-            var result = await client.V5Api.Trading.CancelOrderAsync(Bybit.Net.Enums.Category.Spot, symbol, id);
-            return result.AsDataless();
-        }
-
-        public async Task<Dictionary<string, decimal>> GetBalances()
-        {
-            using var client = new BybitRestClient();
-            var result = await client.V5Api.Account.GetBalancesAsync(Bybit.Net.Enums.AccountType.Spot);
-            return result.Data.List.First().Assets.ToDictionary(d => d.Asset, d => d.WalletBalance);
-        }
-
-        public async Task<IEnumerable<OpenOrder>> GetOpenOrders()
-        {
-            using var client = new BybitRestClient();
-            var order = await client.V5Api.Trading.GetOrdersAsync(Bybit.Net.Enums.Category.Spot);
-            return order.Data.List.Select(o => new OpenOrder
-            {
-                Symbol = o.Symbol,
-                OrderSide = o.Side.ToString(),
-                OrderStatus = o.Status.ToString(),
-                OrderTime = o.CreateTime,
-                OrderType = o.OrderType.ToString(),
-                Price = o.Price ?? 0,
-                Quantity = o.Quantity,
-                QuantityFilled = o.QuantityFilled ?? 0
-            });
-        }
-
-        public async Task<decimal> GetPrice(string symbol)
-        {
-            using var client = new BybitRestClient();
-            var result = await client.V5Api.ExchangeData.GetSpotTickersAsync(symbol);
-            return result.Data.List.First().LastPrice;
-        }
-
-        public async Task<WebCallResult<string>> PlaceOrder(string symbol, string side, string type, decimal quantity, decimal? price)
-        {
-            using var client = new BybitRestClient();
-            var result = await client.V5Api.Trading.PlaceOrderAsync(
-                Bybit.Net.Enums.Category.Spot,
-                symbol,
-                side.ToLower() == "buy" ? Bybit.Net.Enums.OrderSide.Buy : Bybit.Net.Enums.OrderSide.Sell,
-                type == "market" ? Bybit.Net.Enums.NewOrderType.Market : Bybit.Net.Enums.NewOrderType.Limit,
-                quantity,
-                price: price);
-            return result.As(result.Data?.OrderId.ToString());
-        }
-
-        public async Task<UpdateSubscription> SubscribePrice(string symbol, Action<decimal> handler)
-        {
-            var sub = await _socketClient.V5SpotApi.SubscribeToTickerUpdatesAsync(symbol, data => handler(data.Data.LastPrice));
-            return sub.Data;
-        }
-    }
-}

Examples/ConsoleClient/Exchanges/FTXExchange.cs

@@ -0,0 +1,74 @@
+using ConsoleClient.Models;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Sockets;
+using FTX.Net.Clients;
+using FTX.Net.Interfaces.Clients;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ConsoleClient.Exchanges
+{
+    internal class FTXExchange : IExchange
+    {
+        private IFTXSocketClient _socketClient = new FTXSocketClient();
+
+        public async Task<WebCallResult> CancelOrder(string symbol, string id)
+        {
+            using var client = new FTXClient();
+            var result = await client.TradeApi.Trading.CancelOrderAsync(long.Parse(id));
+            return result.AsDataless();
+        }
+
+        public async Task<Dictionary<string, decimal>> GetBalances()
+        {
+            using var client = new FTXClient();
+            var result = await client.TradeApi.Account.GetBalancesAsync();
+            return result.Data.ToDictionary(d => d.Asset, d => d.Total);
+        }
+
+        public async Task<IEnumerable<OpenOrder>> GetOpenOrders()
+        {
+            using var client = new FTXClient();
+            var order = await client.TradeApi.Trading.GetOpenOrdersAsync();
+            return order.Data.Select(o => new OpenOrder
+            {
+                Symbol = o.Symbol,
+                OrderSide = o.Side.ToString(),
+                OrderStatus = o.Status.ToString(),
+                OrderTime = o.CreateTime,
+                OrderType = o.Type.ToString(),
+                Price = o.Price ?? 0,
+                Quantity = o.Quantity,
+                QuantityFilled = o.QuantityFilled ?? 0
+            });
+        }
+
+        public async Task<decimal> GetPrice(string symbol)
+        {
+            using var client = new FTXClient();
+            var result = await client.TradeApi.ExchangeData.GetSymbolAsync(symbol);
+            return result.Data.LastPrice ?? 0;
+        }
+
+        public async Task<WebCallResult<string>> PlaceOrder(string symbol, string side, string type, decimal quantity, decimal? price)
+        {
+            using var client = new FTXClient();
+            var result = await client.TradeApi.Trading.PlaceOrderAsync(
+                symbol,
+                side.ToLower() == "buy" ? FTX.Net.Enums.OrderSide.Buy : FTX.Net.Enums.OrderSide.Sell,
+                type == "market" ? FTX.Net.Enums.OrderType.Market : FTX.Net.Enums.OrderType.Limit,
+                quantity,
+                price: price);
+            return result.As(result.Data?.Id.ToString());
+        }
+
+        public async Task<UpdateSubscription> SubscribePrice(string symbol, Action<decimal> handler)
+        {
+            var sub = await _socketClient.Streams.SubscribeToTickerUpdatesAsync(symbol, data => handler(data.Data.LastPrice ?? 0));
+            return sub.Data;
+        }
+    }
+}

Examples/ConsoleClient/Program.cs

@@ -5,10 +5,12 @@ using System.Linq;
 using System.Threading.Tasks;
 using Binance.Net.Clients;
 using Binance.Net.Objects;
-using Bybit.Net.Clients;
 using ConsoleClient.Exchanges;
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Sockets;
+using FTX.Net.Clients;
+using FTX.Net.Objects;
+using Microsoft.Extensions.Logging;
 
 namespace ConsoleClient
 {
@@ -17,18 +19,20 @@ namespace ConsoleClient
         static Dictionary<string, IExchange> _exchanges = new Dictionary<string, IExchange>
         {
             { "Binance", new BinanceExchange() },
-            { "Bybit", new BybitExchange() }
+            { "FTX", new FTXExchange() }
         };
 
         static async Task Main(string[] args)
         {
-            BinanceRestClient.SetDefaultOptions(options =>
+            BinanceClient.SetDefaultOptions(new BinanceClientOptions
             {
-                options.ApiCredentials = new ApiCredentials("APIKEY", "APISECRET");
+                LogLevel = LogLevel.Trace,
+                ApiCredentials = new ApiCredentials("APIKEY", "APISECRET")
             });
-            BybitRestClient.SetDefaultOptions(options =>
+            FTXClient.SetDefaultOptions(new FTXClientOptions
             {
-                options.ApiCredentials = new ApiCredentials("APIKEY", "APISECRET");
+                LogLevel = LogLevel.Trace,
+                ApiCredentials = new ApiCredentials("APIKEY", "APISECRET")
             });
 
             while (true)

README.md

@@ -1,5 +1,5 @@
 # CryptoExchange.Net
-[![.NET](https://github.com/JKorf/CryptoExchange.Net/actions/workflows/dotnet.yml/badge.svg?branch=master)](https://github.com/JKorf/CryptoExchange.Net/actions/workflows/dotnet.yml) [![Nuget version](https://img.shields.io/nuget/v/CryptoExchange.Net.svg)](https://www.nuget.org/packages/CryptoExchange.Net)  [![Nuget downloads](https://img.shields.io/nuget/dt/CryptoExchange.Net.svg)](https://www.nuget.org/packages/CryptoExchange.Net)
+[![.NET](https://github.com/JKorf/CryptoExchange.Net/actions/workflows/dotnet.yml/badge.svg?branch=master)](https://github.com/JKorf/CryptoExchange.Net/actions/workflows/dotnet.yml) ![Nuget version](https://img.shields.io/nuget/v/CryptoExchange.Net.svg)  ![Nuget downloads](https://img.shields.io/nuget/dt/CryptoExchange.Net.svg)
 
 CryptoExchange.Net is a base package which can be used to easily implement crypto currency exchange API's in C#. This library offers base classes for creating rest and websocket clients, and includes additional features like an automatically synchronizing order book implementation, error handling and automatic reconnects on websocket connections.
 
@@ -8,111 +8,16 @@ CryptoExchange.Net is a base package which can be used to easily implement crypt
 ## Discord
 A Discord server is available [here](https://discord.gg/MSpeEtSY8t). Feel free to join for discussion and/or questions around the CryptoExchange.Net and implementation libraries.
 
-## Support the project
-I develop and maintain this package on my own for free in my spare time, any support is greatly appreciated.
+## Donate / Sponsor
+I develop and maintain this package on my own for free in my spare time. Donations are greatly appreciated. If you prefer to donate any other currency please contact me.
 
-### Referral link
-Use one of the following following referral links to signup to a new exchange to pay a small percentage of the trading fees you pay to support the project instead of paying them straight to the exchange. This doesn't cost you a thing!
-[Binance](https://accounts.binance.com/en/register?ref=10153680)  
-[Bitfinex](https://www.bitfinex.com/sign-up?refcode=kCCe-CNBO)  
-[Bittrex](https://bittrex.com/discover/join?referralCode=TST-DJM-CSX)  
-[Bybit](https://partner.bybit.com/b/jkorf)  
-[CoinEx](https://www.coinex.com/register?refer_code=hd6gn)  
-[Huobi](https://www.huobi.com/en-us/v/register/double-invite/?inviter_id=11343840&invite_code=fxp93)  
-[Kucoin](https://www.kucoin.com/ucenter/signup?rcode=RguMux)  
+**Btc**:  12KwZk3r2Y3JZ2uMULcjqqBvXmpDwjhhQS  
+**Eth**:  0x069176ca1a4b1d6e0b7901a6bc0dbf3bb0bf5cc2  
+**Nano**: xrb_1ocs3hbp561ef76eoctjwg85w5ugr8wgimkj8mfhoyqbx4s1pbc74zggw7gs  
 
-### Donate
-Make a one time donation in a crypto currency of your choice. If you prefer to donate a currency not listed here please contact me.
-
-**Btc**:  bc1qz0jv0my7fc60rxeupr23e75x95qmlq6489n8gh  
-**Eth**:  0x8E21C4d955975cB645589745ac0c46ECA8FAE504  
-
-### Sponsor
-Alternatively, sponsor me on Github using [Github Sponsors](https://github.com/sponsors/JKorf). 
+Alternatively, sponsor me on Github using [Github Sponsors](https://github.com/sponsors/JKorf)  
 
 ## Release notes
-* Version 6.1.4 - 23 Sep 2023
-    * Added BoolConverter
-    * Added parameter for logging warning message on missing enum entry to EnumConverter
-
-* Version 6.1.3 - 18 Sep 2023
-    * Fix for concurrency exception in socket subscription
-
-* Version 6.1.2 - 11 Sep 2023
-    * Added support for multiple of the same ratelimiting type in the same rate limiter
-    * Fixed nullreference on rate limit error if no Retry-After header is returned
-
-* Version 6.1.1 - 04 Sep 2023
-    * Fixes for json converters
-
-* Version 6.1.0 - 24 Aug 2023
-    * Added support for ratelimiting on socket connections
-    * Added rest ratelimit handling and parsing
-    * Added ServerRatelimitError error
-
-* Version 6.0.3 - 23 Jul 2023
-    * Fixed Proxy not getting applied in rest clients when not using DI
-
-* Version 6.0.2 - 05 Jul 2023
-    * Added properties generic dictionary to SocketConnection
-
-* Version 6.0.1 - 29 Jun 2023
-    * Added LogLevel optional parameter to TraceLoggerProvider
-
-* Version 6.0.0 - 25 Jun 2023
-    * Updated ApiCredentials to support RSA signing as well as the default Hmac signature
-    * Removed custom logging implementation in favor of using `Microsoft.Extensions.Logging` ILogger directly
-    * Refactored client options for easier use
-    * Added easier way of switching environments
-    * Added ResponseLength and ToString() override on WebCallResult object
-    * Fixed memory leak in AsyncResetEvent
-
-* Version 5.4.3 - 14 Apr 2023
-    * Fixed potential threading exception in socket connection
-
-* Version 5.4.2 - 01 Apr 2023
-    * Reverted socket changes as it seems to cause reconnect to hang
-
-* Version 5.4.1 - 18 Mar 2023
-    * Added CalculateTradableAmount to SymbolOrderBook
-    * Improved socket reconnect robustness
-    * Fixed api rate limiter not working correctly
-
-* Version 5.4.0 - 14 Feb 2023
-    * Added unsubscribing when receiving subscribe answer after the request timeout has passed
-    * Fixed socket options copying
-    * Made TimeSync implementation optional
-    * Cleaned up ApiCredentials and added better support for extending ApiCredentials
-
-* Version 5.3.1 - 08 Dec 2022
-    * Added default request parameter ordering before applying authentication
-    * Fixed possible issue where a socket would reconnect when it should close if it was already in reconnecting
-
-* Version 5.3.0 - 14 Nov 2022
-    * Reworked client architecture, shifting funcationality to the ApiClient
-    * Fixed ArrayConverter exponent parsing
-    * Fixed ArrayConverter not checking null
-    * Added optional delay setting after establishing socket connection
-    * Added callback for revitalizing a socket request when reconnecting
-    * Fixed proxy setting websocket
-
-* Version 5.2.4 - 31 Jul 2022
-    * Added handling of PlatformNotSupportedException when trying to use websocket from WebAssembly
-    * Changed DataEvent to have a public constructor for testing purposes
-    * Fixed EnumConverter serializing values without proper quotes
-    * Fixed websocket connection reconnecting too quickly when resubscribing/reauthenticating fails
-
-* Version 5.2.3 - 19 Jul 2022
-    * Fixed socket getting disconnected when `no data` timeout is reached instead of being reconnected
-
-* Version 5.2.2 - 17 Jul 2022
-    * Added support for retrieving a new url when socket connection is lost and reconnection will happen
-
-* Version 5.2.1 - 16 Jul 2022
-    * Fixed socket reconnect issue
-    * Fixed `message not handled` messages after unsubscribing
-    * Fixed error returning for non-json error responses
-
 * Version 5.2.0 - 10 Jul 2022
     * Refactored websocket code, removed some clutter and simplified
     * Added ReconnectAsync and GetSubscriptionsState methods on socket clients

docs/Clients.md

@@ -5,23 +5,22 @@ nav_order: 2
 
 ## How to use the library
 
-Each implementation generally provides two different clients, which will be the access point for the API's. First of is the rest client, which is typically available via [ExchangeName]RestClient, and a socket client, which is generally named [ExchangeName]SocketClient. For example `BinanceRestClient` and `BinanceSocketClient`.
+Each implementation generally provides two different clients, which will be the access point for the API's. First of the rest client, which is typically available via [ExchangeName]Client, and a socket client, which is generally named [ExchangeName]SocketClient. For example `BinanceClient` and `BinanceSocketClient`.
 
 ## Rest client
 The rest client gives access to the Rest endpoint of the API. Rest endpoints are accessed by sending an HTTP request and receiving a response. The client is split in different sub-clients, which are named API Clients. These API clients are then again split in different topics. Typically a Rest client will look like this:
 
-- [ExchangeName]RestClient
-    - SpotApi
-        - Account
-        - ExchangeData
-        - Trading
-    - FuturesApi
-        - Account
-        - ExchangeData
-        - Trading
-        
+- KucoinClient
+	- SpotApi
+		- Account
+		- ExchangeData
+		- Trading
+	- FuturesApi
+		- Account
+		- ExchangeData
+		- Trading
+		
 This rest client has 2 different API clients, the `SpotApi` and the `FuturesApi`, each offering their own set of endpoints.  
-
 *Requesting ticker info on the spot API*
 ```csharp
 var client = new KucoinClient();
@@ -31,7 +30,7 @@ var tickersResult = kucoinClient.SpotApi.ExchangeData.GetTickersAsync();
 Structuring the client like this should make it easier to find endpoints and allows for separate options and functionality for different API clients. For example, some API's have totally separate API's for futures, with different base addresses and different API credentials, while other API's have implemented this in the same API. Either way, this structure can facilitate a similar interface.
 
 ### Rest API client
-The Api clients are parts of the total API with a common identifier. In the previous example, it separates the Spot and the Futures API. This again is then separated into topics. Most Rest clients implement the following structure:  
+The Api clients are parts of the total API with a common identifier. In the previous Kucoin example, it separates the Spot and the Futures API. This again is then separated into topics. Most Rest clients implement the following structure:  
 
 **Account**  
 Endpoints related to the user account. This can for example be endpoints for accessing account settings, or getting account balances. The endpoints in this topic will require API credentials to be provided in the client options.
@@ -45,41 +44,35 @@ Endpoints related to trading. These are endpoints for placing and retrieving ord
 
 ### Processing request responses
 Each request will return a WebCallResult<T> with the following properties:  
-`RequestHeaders`: The headers send to the server in the request message  
-`RequestMethod`: The Http method of the request  
-`RequestUrl`: The url the request was send to  
-`ResponseLength`: The length in bytes of the response message  
-`ResponseTime`: The duration between sending the request and receiving the response  
-`ResponseHeaders`: The headers returned from the server  
-`ResponseStatusCode`: The status code as returned by the server  
-`Success`: Whether or not the call was successful. If successful the `Data` property will contain the resulting data, if not successful the `Error` property will contain more details about what the issue was  
-`Error`: Details on what went wrong with a call. Only filled when `Success` == `false`  
-`OriginalData`: Will contain the originally received unparsed data if this has been enabled in the client options
-`Data`: Data returned by the server, only available if `Success` == `true`  
+`ResponseHeaders`: The headers returned from the server
+`ResponseStatusCode`: The status code as returned by the server
+`Success`: Whether or not the call was successful. If successful the `Data` property will contain the resulting data, if not successful the `Error` property will contain more details about what the issue was
+`Error`: Details on what went wrong with a call. Only filled when `Success` == `false`
+`Data`: Data returned by the server
 
-When processing the result of a call it should always be checked for success. Not doing so will result in `NullReference` exceptions when the call fails for whatever reason.
+When processing the result of a call it should always be checked for success. Not doing so will result in `NullReference` exceptions.
 
 *Check call result*
 ```csharp
 var callResult = await kucoinClient.SpotApi.ExchangeData.GetTickersAsync();
 if(!callResult.Success)
 {
-    Console.WriteLine("Request failed: " + callResult.Error);
-    return;
+	Console.WriteLine("Request failed: " + callResult.Error);
+	return;
 }
 
 Console.WriteLine("Result: " + callResult.Data);
 ```
 
 ## Socket client
-The socket client gives access to the websocket API of an exchange. Websocket API's offer streams to which updates are pushed to which a client can listen, and sometimes also allow request/response communication.
+The socket client gives access to the websocket API of an exchange. Websocket API's offer streams to which updates are pushed to which a client can listen. Some exchanges also offer some degree of functionality by allowing clients to give commands via the websocket, but most exchanges only allow this via the Rest API.
 Just like the Rest client is divided in Rest Api clients, the Socket client is divided into Socket Api clients, each with their own range of API functionality. Socket Api clients are generally not divided into topics since the number of methods isn't as big as with the Rest client. To use the Kucoin client as example again, it looks like this:
 
 ```csharp
 
 - KucoinSocketClient
-    - SpotStreams
-    - FuturesStreams
+	- SpotStreams
+	- FuturesStreams
 
 ```
 *Subscribing to updates for all tickers on the Spot Api*
@@ -87,7 +80,7 @@ Just like the Rest client is divided in Rest Api clients, the Socket client is d
 var subscribeResult = kucoinSocketClient.SpotStreams.SubscribeToAllTickerUpdatesAsync(DataHandler);
 ```
 
-Subscribe methods always require a data handler parameter, which is the method which will be called when an update is received from the server. This can be the name of a method or a lambda expression.  
+Subscribe methods require a data handler parameter, which is the method which will be called when an update is received from the server. This can be the name of a method or a lambda expression.  
 
 *Method reference*
 ```csharp
@@ -95,7 +88,7 @@ await kucoinSocketClient.SpotStreams.SubscribeToAllTickerUpdatesAsync(DataHandle
 
 private static void DataHandler(DataEvent<KucoinStreamTick> updateData)
 {
-    // Process updateData
+	// Process updateData
 }
 ```
 
@@ -103,35 +96,31 @@ private static void DataHandler(DataEvent<KucoinStreamTick> updateData)
 ```csharp
 await kucoinSocketClient.SpotStreams.SubscribeToAllTickerUpdatesAsync(updateData =>
 {
-    // Process updateData
+	// Process updateData
 });
 ```
 
-All updates are wrapped in a `DataEvent<>` object, which contain the following properties:  
-`Timestamp`: The timestamp when the data was received (not send!)  
-`OriginalData`: Will contain the originally received unparsed data if this has been enabled in the client options  
-`Topic`: Will contain the topic of the update, which is typically the symbol or asset the update is for  
-`Data`: Contains the received update data.
+All updates are wrapped in a `DataEvent<>` object, which contain a `Timestamp`, `OriginalData`, `Topic`, and a `Data` property. The `Timestamp` is the timestamp when the data was received (not send!). `OriginalData` will contain the originally received data if this has been enabled in the client options. `Topic` will contain the topic of the update, which is typically the symbol or asset the update is for. The `Data` property contains the received update data.
 
-*[WARNING] Do not use `using` statements in combination with constructing a `SocketClient` without blocking the thread. Doing so will dispose the `SocketClient` instance when the subscription is done, which will result in the connection getting closed. Instead assign the socket client to a variable outside of the method scope.*
+*[WARNING] Do not use `using` statements in combination with constructing a `SocketClient`. Doing so will dispose the `SocketClient` instance when the subscription is done, which will result in the connection getting closed. Instead assign the socket client to a variable outside of the method scope.*
 
 ### Processing subscribe responses
-Subscribing to a stream will return a `CallResult<UpdateSubscription>` object. This should be checked for success the same way as a [rest request](#processing-request-responses). The `UpdateSubscription` object can be used to listen for connection events of the socket connection. 
+Subscribing to a stream will return a `CallResult<UpdateSubscription>` object. This should be checked for success the same was as the [rest client](#processing-request-responses). The `UpdateSubscription` object can be used to listen for connection events of the socket connection. 
 ```csharp
 
 var subscriptionResult = await kucoinSocketClient.SpotStreams.SubscribeToAllTickerUpdatesAsync(DataHandler);
 if(!subscriptionResult.Success)
 {
-    Console.WriteLine("Failed to connect: " + subscriptionResult.Error);
-    return;
+	Console.WriteLine("Failed to connect: " + subscriptionResult.Error);
+	return;
 }
 subscriptionResult.Data.ConnectionLost += () =>
 {
-    Console.WriteLine("Connection lost");
+	Console.WriteLine("Connection lost");
 };
 subscriptionResult.Data.ConnectionRestored += (time) =>
 {
-    Console.WriteLine("Connection restored");
+	Console.WriteLine("Connection restored");
 };
 
 ```
@@ -169,3 +158,34 @@ await kucoinSocketClient.UnsubscribeAsync(subscriptionResult.Data.Id);
 When you need to unsubscribe all current subscriptions on a client you can call `UnsubscribeAllAsync` on the client to unsubscribe all streams and close all connections.
 
 
+## Dependency injection
+Each library offers a `Add[Library]` extension method for `IServiceCollection`, which allows you to add the clients to the service collection. It also provides a callback for setting the client options. See this example for adding the `BinanceClient`:
+```csharp
+public void ConfigureServices(IServiceCollection services)
+{
+	services.AddBinance((restClientOptions, socketClientOptions) => {
+		restClientOptions.ApiCredentials = new ApiCredentials("KEY", "SECRET");
+		restClientOptions.LogLevel = LogLevel.Trace;
+
+		socketClientOptions.ApiCredentials = new ApiCredentials("KEY", "SECRET");
+	});
+}
+```
+Doing client registration this way will add the `IBinanceClient` as a transient service, and the `IBinanceSocketClient` as a scoped service.
+
+Alternatively, the clients can be registered manually:
+```csharp
+BinanceClient.SetDefaultOptions(new BinanceClientOptions
+{
+	ApiCredentials = new ApiCredentials("KEY", "SECRET"),
+	LogLevel = LogLevel.Trace
+});
+
+BinanceSocketClient.SetDefaultOptions(new BinanceSocketClientOptions
+{
+	ApiCredentials = new ApiCredentials("KEY", "SECRET"),
+});
+
+services.AddTransient<IBinanceClient, BinanceClient>();
+services.AddScoped<IBinanceSocketClient, BinanceSocketClient>();
+```

docs/FAQ.md

@@ -1,6 +1,6 @@
 ---
 title: FAQ
-nav_order: 12
+nav_order: 11
 ---
 
 ## Frequently asked questions
@@ -28,7 +28,7 @@ private void SomeMethod()
 {
   var socketClient = new BinanceSocketClient();
   socketClient.Spot.SubscribeToOrderBookUpdates("BTCUSDT", data => {
-    // Handle data
+	// Handle data
   });
 }
 ```
@@ -41,18 +41,25 @@ private BinanceSocketClient _socketClient = new BinanceSocketClient();
 private void SomeMethod()
 {
   _socketClient.Spot.SubscribeToOrderBookUpdates("BTCUSDT", data => {
-    // Handle data
+	// Handle data
   });
 }
 
 ```
 
 ### Can I use the TestNet/US/other API with this library
-Yes, generally these are all supported and can be configured by setting the Environment in the client options. Some known environments should be available in the [Exchange]Environment class. For example:
+Yes, generally these are all supported and can be configured by setting the BaseAddress in the client options. Some known API addresses should be available in the [Exchange]ApiAddresses class. For example:
 ```csharp
-var client = new BinanceRestClient(options =>
+var client = new BinanceClient(new BinanceClientOptions
 {
-    options.Environment = BinanceEnvironment.Testnet;
+	SpotApiOptions = new BinanceApiClientOptions
+	{
+		BaseAddress = BinanceApiAddresses.TestNet.RestClientAddress
+	},
+	UsdFuturesApiOptions = new BinanceApiClientOptions
+	{
+		BaseAddress = BinanceApiAddresses.TestNet.UsdFuturesRestClientAddress
+	}
 });
 ```
 

docs/Glossary.md

@@ -1,6 +1,6 @@
 ---
 title: Glossary
-nav_order: 11
+nav_order: 10
 ---
 ## Terms and definitions
 
@@ -18,7 +18,7 @@ nav_order: 11
 |Network|Chain|The network of an asset. For example `ETH` allows multiple networks like `ERC20` and `BEP2`|
 |Order book|Market depth|A list of (the top rows of) the current best bids and asks|
 |Ticker|Stats|Statistics over the last 24 hours|
-|Client implementation|Library|An implementation of the `CrytpoExchange.Net` library. For example `Binance.Net` or `Bybit.Net`|
+|Client implementation|Library|An implementation of the `CrytpoExchange.Net` library. For example `Binance.Net` or `FTX.Net`|
 
 ### Other naming conventions
 #### PlaceOrderAsync

docs/Interfaces.md

@@ -1,6 +1,6 @@
 ---
 title: Common interfaces
-nav_order: 7
+nav_order: 5
 ---
 
 ## Shared interfaces

docs/Logging.md

@@ -1,114 +1,320 @@
 ---
-title: Logging
-nav_order: 5
+title: Log config
+nav_order: 4
 ---
 
 ## Configuring logging
-The library offers extensive logging, which depends on the dotnet `Microsoft.Extensions.Logging.ILogger` interface. This should provide ease of use when connecting the library logging to your existing logging implementation.
+The library offers extensive logging, for which you can supply your own logging implementation. The logging can be configured via the client options (see [Client options](https://github.com/JKorf/CryptoExchange.Net/wiki/Options)). The examples here are using the `BinanceClient` but they should be the same for each implementation.
 
-*Configure logging to write to the console*
+Logging is based on the `Microsoft.Extensions.Logging.ILogger` interface. This should provide ease of use when connecting the library logging to your existing logging implementation.
+
+## Serilog
+To make the CryptoExchange.Net logging write to the Serilog logger you can use the following methods, depending on the type of project you're using. The following examples assume that the `Serilog.Sinks.Console` package is already installed.
+
+### Dotnet hosting
+
+With for example an ASP.Net Core or Blazor project the logging can be added to the dependency container, which you can then use to inject it into the client. Make sure to install the `Serilog.AspNetCore` package (https://github.com/serilog/serilog-aspnetcore).
+
+<Details>
+<Summary>
+Using ILogger injection
+
+</Summary>
+<BlockQuote>
+Adding `UseSerilog()` in the `CreateHostBuilder` will add the Serilog logging implementation as an ILogger which you can inject into implementations.
+
+*Configuring Serilog as ILogger:*
 ```csharp
-IServiceCollection services = new ServiceCollection();
-services
-    .AddBinance()
-    .AddLogging(options =>
-    {
-        options.SetMinimumLevel(LogLevel.Trace);
-        options.AddConsole();
-    });
-```
 
-The library provides a TraceLogger ILogger implementation which writes log messages using `Trace.WriteLine`, but any other logging library can be used.
-
-*Configure logging to use trace logging*
-```csharp
-IServiceCollection serviceCollection = new ServiceCollection();
-serviceCollection.AddBinance()
-    .AddLogging(options =>
-    {
-        options.SetMinimumLevel(LogLevel.Trace);
-        options.AddProvider(new TraceLoggerProvider());
-    });
-```
-
-### Using an external logging library and dotnet DI
-
-With for example an ASP.Net Core or Blazor project the logging can be configured by the dependency container, which can then automatically be used be the clients.
-The next example shows how to use Serilog. This assumes the `Serilog.AspNetCore` package (https://github.com/serilog/serilog-aspnetcore) is installed.
-
-*Using serilog:*
-```csharp
-using Binance.Net;
-using Serilog;
-
-Log.Logger = new LoggerConfiguration()
-        .MinimumLevel.Debug()
-        .WriteTo.Console()
-        .CreateLogger();
-
-var builder = WebApplication.CreateBuilder(args);
-builder.Services.AddBinance();
-builder.Host.UseSerilog();
-var app = builder.Build();
-
-// startup
-
-app.Run();
-```
-
-### Logging without dotnet DI
-If you don't have a dependency injection service available because you are for example working on a simple console application you have 2 options for logging.
-
-#### Create a ServiceCollection manually and get the client from the service provider
-
-```csharp
-IServiceCollection serviceCollection = new ServiceCollection();
-serviceCollection.AddBinance();
-serviceCollection.AddLogging(options =>
+public static void Main(string[] args)
 {
-    options.SetMinimumLevel(LogLevel.Trace);
-    options.AddConsole();
-}).BuildServiceProvider();
+	Log.Logger = new LoggerConfiguration()
+		.MinimumLevel.Debug()
+		.WriteTo.Console()
+		.CreateLogger();
 
-var client = serviceCollection.GetRequiredService<IBinanceRestClient>();
+	CreateHostBuilder(args).Build().Run();
+}
 
+public static IHostBuilder CreateHostBuilder(string[] args) =>
+	Host.CreateDefaultBuilder(args)
+		.UseSerilog()
+		.ConfigureWebHostDefaults(webBuilder =>
+		{
+			webBuilder.UseStartup<Startup>();
+		});
+				
 ```
 
-#### Create a LoggerFactory manually
 
+*Injecting ILogger:*
 ```csharp
-var logFactory = new LoggerFactory();
-logFactory.AddProvider(new ConsoleLoggerProvider());
-var binanceClient = new BinanceRestClient(new HttpClient(), logFactory, options => { });
+
+public class BinanceDataProvider
+{
+	BinanceClient _client;
+
+	public BinanceDataProvider(ILogger<BinanceDataProvider> logger)
+	{
+		_client = new BinanceClient(new BinanceClientOptions
+		{
+			LogLevel = LogLevel.Trace,
+			LogWriters = new List<ILogger> { logger }
+		});
+
+	}
+}
+
 ```
 
-## Providing logging for issues
+</BlockQuote>
+</Details>
+
+<Details>
+<Summary>
+Using Add[Library] extension method
+
+</Summary>
+<BlockQuote>
+When using the `Add[Library]` extension method, for instance `AddBinance()`, there is a small issue that there is no available `ILogger<>` yet when adding the library. This can be solved as follows:
+
+*Configuring Serilog as ILogger:*
+```csharp
+
+public static void Main(string[] args)
+{
+	Log.Logger = new LoggerConfiguration()
+		.MinimumLevel.Debug()
+		.WriteTo.Console()
+		.CreateLogger();
+
+	CreateHostBuilder(args).Build().Run();
+}
+
+public static IHostBuilder CreateHostBuilder(string[] args) =>
+	Host.CreateDefaultBuilder(args)
+		.ConfigureWebHostDefaults(webBuilder =>
+		{
+			webBuilder.UseStartup(
+				context => new Startup(context.Configuration, LoggerFactory.Create(config => config.AddSerilog()) )); // <- this allows us to use ILoggerFactory in the Startup.cs
+		});
+				
+```
+
+
+*Injecting ILogger:*
+```csharp
+
+public class Startup
+{
+	private ILoggerFactory _loggerFactory;
+
+	public Startup(IConfiguration configuration, ILoggerFactory loggerFactory)
+	{
+		Configuration = configuration;
+		_loggerFactory = loggerFactory;
+	}
+	
+	/* .. rest of class .. */
+	
+	public void ConfigureServices(IServiceCollection services)
+	{
+		services.AddBinance((restClientOptions, socketClientOptions) => {
+			// Point the logging to use the ILogger configuration
+			restClientOptions.LogWriters = new List<ILogger> { _loggerFactory.CreateLogger<IBinanceClient>() };
+		});
+		
+		// Rest of service registrations
+	}
+}
+
+```
+
+</BlockQuote>
+</Details>
+
+### Console application
+If you don't have a dependency injection service available because you are for example working on a simple console application you can use a slightly different approach.  
+
+*Configuring Serilog as ILogger:*
+```csharp
+var serilogLogger = new LoggerConfiguration()
+	.MinimumLevel.Debug()
+	.WriteTo.Console()
+	.CreateLogger();
+
+var loggerFactory = (ILoggerFactory)new LoggerFactory();
+loggerFactory.AddSerilog(serilogLogger);
+
+```
+
+*Injecting ILogger:*
+```csharp
+
+var client = new BinanceClient(new BinanceClientOptions
+{
+	LogLevel = LogLevel.Trace,
+	LogWriters = new List<ILogger> { loggerFactory.CreateLogger("") }
+});
+```
+
+The `BinanceClient` will now write the logging it produces to the Serilog logger.
+
+## Log4Net
+
+To make the CryptoExchange.Net logging write to the Log4Net logge with for example an ASP.Net Core or Blazor project the logging can be added to the dependency container, which you can then use to inject it into the client you're using. Make sure to install the `Microsoft.Extensions.Logging.Log4Net.AspNetCore` package (https://github.com/huorswords/Microsoft.Extensions.Logging.Log4Net.AspNetCore). 
+Adding `AddLog4Net()` in the `ConfigureLogging` call will add the Log4Net implementation as an ILogger which you can inject into implementations. Make sure you have a log4net.config configuration file in your project.
+
+*Configuring Log4Net as ILogger:*
+```csharp
+public static IHostBuilder CreateHostBuilder(string[] args) =>
+	Host.CreateDefaultBuilder(args)
+		.ConfigureWebHostDefaults(webBuilder =>
+		{
+			webBuilder.ConfigureLogging(logging =>
+			{
+				logging.AddLog4Net();
+				logging.SetMinimumLevel(LogLevel.Trace);
+			});
+			webBuilder.UseStartup<Startup>();
+		});
+```
+
+*Injecting ILogger:*
+```csharp
+
+public class BinanceDataProvider
+{
+	BinanceClient _client;
+
+	public BinanceDataProvider(ILogger<BinanceDataProvider> logger)
+	{
+		_client = new BinanceClient(new BinanceClientOptions
+		{
+			LogLevel = LogLevel.Trace,
+			LogWriters = new List<ILogger> { logger }
+		});
+
+	}
+}
+
+```
+
+If you don't have the Dotnet dependency container available you'll need to provide your own ILogger implementation. See [Custom logger](#custom-logger).
+
+## NLog
+To make the CryptoExchange.Net logging write to the NLog logger you can use the following ways, depending on the type of project you're using.
+
+### Dotnet hosting
+
+With for example an ASP.Net Core or Blazor project the logging can be added to the dependency container, which you can then use to inject it into the client you're using. Make sure to install the `NLog.Web.AspNetCore` package (https://github.com/NLog/NLog/wiki/Getting-started-with-ASP.NET-Core-5). 
+Adding `UseNLog()` to the `CreateHostBuilder()` method will add the NLog implementation as an ILogger which you can inject into implementations. Make sure you have a nlog.config configuration file in your project.
+
+*Configuring NLog as ILogger:*
+```csharp
+ public static IHostBuilder CreateHostBuilder(string[] args) =>
+    Host.CreateDefaultBuilder(args)
+        .ConfigureWebHostDefaults(webBuilder =>
+        {
+            webBuilder.UseStartup<Startup>();
+        })
+         .ConfigureLogging(logging =>
+         {
+             logging.ClearProviders();
+             logging.SetMinimumLevel(LogLevel.Trace);
+         })
+        .UseNLog();
+```
+
+*Injecting ILogger:*
+```csharp
+
+public class BinanceDataProvider
+{
+	BinanceClient _client;
+
+	public BinanceDataProvider(ILogger<BinanceDataProvider> logger)
+	{
+		_client = new BinanceClient(new BinanceClientOptions
+		{
+			LogLevel = LogLevel.Trace,
+			LogWriters = new List<ILogger> { logger }
+		});
+
+	}
+}
+
+```
+
+If you don't have the Dotnet dependency container available you'll need to provide your own ILogger implementation. See [Custom logger](#custom-logger).
+
+## Custom logger
+If you're using a different framework or for some other reason these methods don't work for you you can create a custom ILogger implementation to receive the logging. All you need to do is create an implementation of the ILogger interface and provide that to the client.
+
+*A simple console logging implementation (note that the ConsoleLogger is already available in the CryptoExchange.Net library)*:
+```csharp
+
+public class ConsoleLogger : ILogger
+{
+	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)
+	{
+		var logMessage = $"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | {logLevel} | {formatter(state, exception)}";
+		Console.WriteLine(logMessage);
+	}
+}
+
+```
+
+*Injecting the console logging implementation:*
+```csharp
+
+var client = new BinanceClient(new BinanceClientOptions
+{
+	LogLevel = LogLevel.Trace,
+	LogWriters = new List<ILogger> { new ConsoleLogger() }
+});
+
+```
+
+## Provide logging for issues
 A big debugging tool when opening an issue on Github is providing logging of what data caused the issue. This can be provided two ways, via the `OriginalData` property of the call result or data event, or collecting the Trace logging.
 ### OriginalData
 This is only useful when there is an issue in deserialization. So either a call result is giving a Deserialization error, or the result has a value that is unexpected. If that is the issue, please provide the original data that is received so the deserialization issue can be resolved based on the received data.
 By default the `OriginalData` property in the `WebCallResult`/`DataEvent` object is not filled as saving the original data has a (very small) performance penalty. To save the original data in the `OriginalData` property the `OutputOriginalData` option should be set to `true` in the client options.  
 *Enabled output data*
 ```csharp
-var client = new BinanceClient(options =>
+var client = new BinanceClient(new BinanceClientOptions
 {
-    options.OutputOriginalData = true
+	OutputOriginalData = true
 });
 ``` 
 
 *Accessing original data*
 ```csharp
 // Rest request
-var tickerResult = await client.SpotApi.ExchangeData.GetTickersAsync();
-var originallyReceivedData = tickerResult.OriginalData;
+var tickerResult = client.SpotApi.ExchangeData.GetTickersAsync();
+var originallyRecievedData = tickerResult.OriginalData;
 
 // Socket update
-await client.SpotStreams.SubscribeToAllTickerUpdatesAsync(update => {
-    var originallyRecievedData = update.OriginalData;
+client.SpotStreams.SubscribeToAllTickerUpdatesAsync(update => {
+	var originallyRecievedData = update.OriginalData;
 });
 ```
 
 ### Trace logging
-Trace logging, which is the most verbose log level, will show everything the library does and includes the data that was send and received.  
+Trace logging, which is the most verbose log level, can be enabled in the client options.  
+*Enabled output data*
+```csharp
+var client = new BinanceClient(new BinanceClientOptions
+{
+	LogLevel = LogLevel.Trace
+});
+``` 
+After enabling trace logging all data send to/received from the server is written to the log writers. By default this is written to the output window in Visual Studio via Debug.WriteLine, though this might be different depending on how you configured your logging.
 Output data will look something like this:
 ```
 2021-12-17 10:40:42:296 | Debug | Binance    | Client configuration: LogLevel: Trace, Writers: 1, OutputOriginalData: False, Proxy: -, AutoReconnect: True, ReconnectInterval: 00:00:05, MaxReconnectTries: , MaxResubscribeTries: 5, MaxConcurrentResubscriptionsPerSocket: 5, SocketResponseTimeout: 00:00:10, SocketNoDataTimeout: 00:00:00, SocketSubscriptionsCombineTarget: , CryptoExchange.Net: v5.0.0.0, Binance.Net: v8.0.0.0
@@ -117,34 +323,3 @@ Output data will look something like this:
 2021-12-17 10:40:43:024 | Debug | Binance    | [15] Response received in 571ms: {"symbol":"BTCUSDT","priceChange":"-1726.47000000","priceChangePercent":"-3.531","weightedAvgPrice":"48061.51544204","prevClosePrice":"48901.44000000","lastPrice":"47174.97000000","lastQty":"0.00352000","bidPrice":"47174.96000000","bidQty":"0.65849000","askPrice":"47174.97000000","askQty":"0.13802000","openPrice":"48901.44000000","highPrice":"49436.43000000","lowPrice":"46749.55000000","volume":"33136.69765000","quoteVolume":"1592599905.80360790","openTime":1639647642763,"closeTime":1639734042763,"firstId":1191596486,"lastId":1192649611,"count":1053126}
 ```
 When opening an issue, please provide this logging when available.
-
-### Example of serilog config and minimal API's
-
-```csharp
-using Binance.Net;
-using Binance.Net.Interfaces.Clients;
-using Serilog;
-
-Log.Logger = new LoggerConfiguration()
-        .MinimumLevel.Debug()
-        .WriteTo.Console()
-        .CreateLogger();
-
-var builder = WebApplication.CreateBuilder(args);
-builder.Services.AddBinance();
-builder.Host.UseSerilog();
-var app = builder.Build();
-
-// startup
-
-app.Urls.Add("http://localhost:3000");
-
-app.MapGet("/price/{symbol}", async (string symbol) =>
-{
-    var client = app.Services.GetRequiredService<IBinanceRestClient>();
-    var result = await client.SpotApi.ExchangeData.GetPriceAsync(symbol);
-    return result.Data.Price;
-});
-
-app.Run();
-```

docs/Migration Guide.md

@@ -1,73 +1,100 @@
 ---
-title: Migrate v5 to v6
-nav_order: 10
+title: Migrate v4 to v5
+nav_order: 9
 ---
 
-## Migrating from version 5 to version 6
-When updating your code from version 5 implementations to version 6 implementations you will encounter some breaking changes. Here is the general outline of changes made in the CryptoExchange.Net library. For more specific changes for each library visit the library migration guide.
+## Migrating from version 4 to version 5
+When updating your code from version 4 implementations to version 5 implementations you will encounter a fair bit of breaking changes. Here is the general outline for changes made in the CryptoExchange.Net library. For more specific changes for each library visit the library migration guide.
 
-*NOTE when updating it is not possible to have some client implementations use a V5 version and some clients a V6. When updating all libraries should be migrated*
+*NOTE when updating it is not possible to have some client implementations use a V4 version and some clients a V5. When updating all libraries should be migrated*
 
-## Rest client name
-To be more clear about different clients for different API's the rest client implementations have been renamed from [Exchange]Client to [Exchange]RestClient. This makes it more clear that it only implements the Rest API and the [Exchange]SocketClient the Socket API.
+## Client structure
+The client structure has been changed to make clients more consistent across different implementations. Clients using V4 either had `client.Method()`, `client.[Api].Method()` or `client.[Api].[Topic].Method()`.  
 
-## Options
-Option parameters have been changed to a callback instead of an options object. This makes processing of the options easier and is in line with how dotnet handles option configurations.
+This has been unified to be `client.[Api]Api.[Topic].Method()`:  
+`bittrexClient.GetTickersAsync()` -> `bittrexClient.SpotApi.ExchangeData.GetTickersAsync()`  
+`kucoinClient.Spot.GetTickersAsync()` -> `kucoinClient.SpotApi.ExchangeData.GetTickersAsync()`  
+`binanceClient.Spot.Market.GetTickersAsync()` -> `binanceClient.SpotApi.ExchangeData.GetTickersAsync()`  
 
-**BaseAddress**  
-The BaseAddress option has been replaced by the Environment option. The Environment options allows for selection/switching between different trade environments more easily. For example the environment can be switched between a testnet and live by changing only a single line instead of having to change all BaseAddresses.  
+Socket clients are restructured as `client.[Api]Streams.Method()`:
+`bittrexClient.SpotStreams.SubscribeToTickerUpdatesAsync()`  
+`kucoinClient.SpotStreams.SubscribeToTickerUpdatesAsync()`  
+`binanceClient.SpotStreams.SubscribeToAllTickerUpdatesAsync()`  
 
-**LogLevel/LogWriters**  
-The logging options have been removed and are now inherited by the DI configuration. See [Logging](https://jkorf.github.io/CryptoExchange.Net/Logging.html) for more info.  
 
-**HttpClient**
-The HttpClient will now be received by the DI container instead of having to pass it manually. When not using DI it is still possible to provide a HttpClient, but it is now located in the client constructor.
-
-*V5*  
+## Options structure
+The options have been changed in 2 categories, options for the whole client, and options only for a specific sub Api. Some options might no longer be available on the base level and should be set on the Api options instead, for example the `BaseAddress`. 
+The following example sets some basic options, and specifically overwrites the USD futures Api options to use the test net address and different Api credentials:  
+*V4*
 ```csharp
-var client = new BinanceClient(new BinanceClientOptions(){
-    OutputOriginalData = true,
-    SpotApiOptions = new RestApiOptions {
-      BaseAddress = BinanceApiAddresses.TestNet.RestClientAddress
-    }
-    // Other options
+var binanceClient = new BinanceClient(new BinanceApiClientOptions{
+	LogLevel = LogLevel.Trace,
+	RequestTimeout = TimeSpan.FromSeconds(60),
+	ApiCredentials = new ApiCredentials("API KEY", "API SECRET"),
+	BaseAddressUsdtFutures = new ApiCredentials("OTHER API KEY ONLY FOR USD FUTURES", "OTHER API SECRET ONLY FOR USD FUTURES")
+	// No way to set separate credentials for the futures API
 });
 ```
 
-*V6*  
+*V5*
 ```csharp
-var client = new BinanceClient(options => {
-    options.OutputOriginalData = true;
-    options.Environment = BinanceEnvironment.Testnet;
-    // Other options
+var binanceClient = new BinanceClient(new BinanceClientOptions()
+{
+	// Client options
+	LogLevel = LogLevel.Trace,
+	RequestTimeout = TimeSpan.FromSeconds(60),
+	ApiCredentials = new ApiCredentials("API KEY", "API SECRET"),
+	
+	// Set options specifically for the USD futures API
+	UsdFuturesApiOptions = new BinanceApiClientOptions
+	{
+		BaseAddress = BinanceApiAddresses.TestNet.UsdFuturesRestClientAddress,
+		ApiCredentials = new ApiCredentials("OTHER API KEY ONLY FOR USD FUTURES", "OTHER API SECRET ONLY FOR USD FUTURES")
+	}
 });
 ```
+See [Client options](https://github.com/JKorf/CryptoExchange.Net/wiki/Options) for more details on the specific options.
 
-## Socket api name
-As socket API's are often more than just streams to subscribe to the name of the socket API clients have been changed from [Topic]Streams to [Topic]Api which matches the rest API client names. For example `SpotStreams` has become `SpotApi`, so `binanceSocketClient.UsdFuturesStreams.SubscribeXXX` has become `binanceSocketClient.UsdFuturesApi.SubscribeXXX`.
-
-## Add[Exchange] extension method
-With the change in options providing the DI extension methods for the IServiceCollection have also been changed slightly. Also the socket clients will now be registered as Singleton by default instead of Scoped.
-
-*V5*  
+## IExchangeClient
+The `IExchangeClient` has been replaced by the `ISpotClient` and `IFuturesClient`. Where previously the `IExchangeClient` was implemented on the base client level, the `ISpotClient`/`IFuturesClient` have been implemented on the sub-Api level.
+This, in combination with the client restructuring, allows for more logically implemented interfaces, see this example:  
+*V4*
 ```csharp
-builder.Services.AddKucoin((restOpts, socketOpts) =>
-{
-    restOpts.LogLevel = LogLevel.Debug;
-    restOpts.ApiCredentials = new KucoinApiCredentials("KEY", "SECRET", "PASS");
-    socketOpts.LogLevel = LogLevel.Debug;
-    socketOpts.ApiCredentials = new KucoinApiCredentials("KEY", "SECRET", "PASS");
-}, ServiceLifetime.Singleton);
+var spotClients = new [] {
+	(IExhangeClient)binanceClient,
+	(IExchangeClient)bittrexClient,
+	(IExchangeClient)kucoinClient.Spot
+};
+
+// There was no common implementation for futures client
 ```
 
-*V6*  
+*V5*
 ```csharp
-builder.Services.AddKucoin((restOpts) =>
-{
-    restOpts.ApiCredentials = new KucoinApiCredentials("KEY", "SECRET", "PASS");
-},
-(socketOpts) =>
-{
-    socketOpts.ApiCredentials = new KucoinApiCredentials("KEY", "SECRET", "PASS");
-});
-```
+var spotClients = new [] {
+	binanceClient.SpotApi.CommonSpotClient,
+	bittrexClient.SpotApi.CommonSpotClient,
+	kucoinClient.SpotApi.CommonSpotClient
+};
+
+var futuresClients = new [] {
+	binanceClient.UsdFuturesApi.CommonFuturesClient,
+	kucoinClient.FuturesApi.CommonFuturesClient
+};
+```
+
+Where the IExchangeClient was returning interfaces which were implemented by models from the exchange, the `ISpotClient`/`IFuturesClient` returns actual objects defined in the `CryptoExchange.Net` library. This shifts the responsibility of parsing 
+the library model to a shared model from the model class to the client class, which makes more sense and removes the need for separate library models to implement the same mapping logic. It also removes the need for the `Common` prefix on properties:  
+*V4*
+```csharp
+var kline = await ((IExhangeClient)binanceClient).GetKlinesAysnc(/*params*/);
+var closePrice = kline.CommonClose;
+```
+
+*V5*
+```csharp
+var kline = await binanceClient.SpotApi.ComonSpotClient.GetKlinesAysnc(/*params*/);
+var closePrice = kline.ClosePrice;
+```
+
+For more details on the interfaces see [Common interfaces](interfaces.html)

docs/Options.md

@@ -1,6 +1,6 @@
 ---
 title: Client options
-nav_order: 4
+nav_order: 3
 ---
 
 ## Setting client options
@@ -10,12 +10,10 @@ Each implementation can be configured using client options. There are 2 ways to
 *Set the default options to use for new clients*
 ```csharp
 
-BinanceClient.SetDefaultOptions(options =>
+BinanceClient.SetDefaultOptions(new BinanceClientOptions
 {
-    options.OutputOriginalData = true;
-    options.ApiCredentials = new ApiCredentials("KEY", "SECRET");
-	// Override the api credentials for the Spot API
-    options.SpotOptions.ApiCredentials = new ApiCredentials("SPOT-KEY", "SPOT-SECRET");
+	LogLevel = LogLevel.Trace,
+	ApiCredentials = new ApiCredentials("KEY", "SECRET")
 });
 
 ```
@@ -23,12 +21,10 @@ BinanceClient.SetDefaultOptions(options =>
 *Set the options to use for a single new client*
 ```csharp
 
-var client = new BinanceClient(options =>
+var client = new BinanceClient(new BinanceClientOptions
 {
-    options.OutputOriginalData = true;
-    options.ApiCredentials = new ApiCredentials("KEY", "SECRET");
-	// Override the api credentials for the Spot API
-    options.SpotOptions.ApiCredentials = new ApiCredentials("SPOT-KEY", "SPOT-SECRET");
+	LogLevel = LogLevel.Trace,
+	ApiCredentials = new ApiCredentials("KEY", "SECRET")
 });
 
 ```
@@ -36,30 +32,39 @@ var client = new BinanceClient(options =>
 When calling `SetDefaultOptions` each client created after that will use the options that were set, unless the specific option is overriden in the options that were provided to the client. Consider the following example:
 ```csharp
 
-BinanceClient.SetDefaultOptions(options =>
+BinanceClient.SetDefaultOptions(new BinanceClientOptions
 {
-    options.OutputOriginalData = true;
+	LogLevel = LogLevel.Trace,
+	OutputOriginalData = true
 });
 
-var client = new BinanceClient(options =>
+var client = new BinanceClient(new BinanceClientOptions
 {
-    options.OutputOriginalData = false;
+	LogLevel = LogLevel.Debug,
+	ApiCredentials = new ApiCredentials("KEY", "SECRET")
 });
 
 ```
 
 The client instance will have the following options:  
-`OutputOriginalData = false`  
+`LogLevel = Debug`  
+`OutputOriginalData = true`  
+`ApiCredentials = set`  
 
 ## Api options
-The options are divided in two categories. The basic options, which will apply to everything the client does, and the Api options, which is limited to the specific API client (see [Clients](https://jkorf.github.io/CryptoExchange.Net/Clients.html)).
+The options are divided in two categories. The basic options, which will apply to everything the client does, and the Api options, which is limited to the specific API client (see [Clients](https://github.com/JKorf/CryptoExchange.Net/wiki/Clients)).
 
 ```csharp
 
-var client = new BinanceRestClient(options =>
+var client = new BinanceClient(new BinanceClientOptions
 {
-    options.ApiCredentials = new ApiCredentials("GENERAL-KEY", "GENERAL-SECRET"),
-    options.SpotOptions.ApiCredentials = new ApiCredentials("SPOT-KEY", "SPOT-SECRET");
+	LogLevel = LogLevel.Debug,
+	ApiCredentials = new ApiCredentials("GENERAL-KEY", "GENERAL-SECRET"),
+	SpotApiOptions = new BinanceApiClientOptions
+	{
+		ApiCredentials = new ApiCredentials("SPOT-KEY", "SPOT-SECRET")              ,
+		BaseAddress = BinanceApiAddresses.Us.RestClientAddress
+	}
 });
 
 ```
@@ -73,39 +78,38 @@ All clients have access to the following options, specific implementations might
 
 |Option|Description|Default|
 |------|-----------|-------|
+|`LogWriters`| A list of `ILogger`s to handle log messages. | `new List<ILogger> { new DebugLogger() }` |
+|`LogLevel`| The minimum log level before passing messages to the `LogWriters`. Messages with a more verbose level than the one specified here will be ignored. Setting this to `null` will pass all messages to the `LogWriters`.| `LogLevel.Information`
 |`OutputOriginalData`|If set to `true` the originally received Json data will be output as well as the deserialized object. For `RestClient` calls the data will be in the `WebCallResult<T>.OriginalData` property, for `SocketClient` subscriptions the data will be available in the `DataEvent<T>.OriginalData` property when receiving an update. | `false`
-|`ApiCredentials`| The API credentials to use for accessing protected endpoints. Can either be an API key/secret using Hmac encryption or an API key/private key using RSA encryption for exchanges that support that. See [Credentials](#credentials). Note that this is a `default` value for all API clients, and can be overridden per API client. See the `Base Api client options`| `null`
+|`ApiCredentials`| The API credentials to use for accessing protected endpoints. Typically a key/secret combination. Note that this is a `default` value for all API clients, and can be overridden per API client. See the `Base Api client options`| `null`
 |`Proxy`|The proxy to use for connecting to the API.| `null`
-|`RequestTimeout`|The timeout for client requests to the server| `TimeSpan.FromSeconds(20)`
 
 **Rest client options (extension of base client options)** 
  
 |Option|Description|Default|
 |------|-----------|-------|
-|`AutoTimestamp`|Whether or not the library should attempt to sync the time between the client and server. If the time between server and client is not in sync authentication errors might occur. This option should be disabled when the client time sure to be in sync.|`true`|
-|`TimestampRecalculationInterval`|The interval of how often the time synchronization between client and server should be executed| `TimeSpan.FromHours(1)`
-|`Environment`|The environment the library should talk to. Some exchanges have testnet/sandbox environments which can be used instead of the real exchange. The environment option can be used to switch between different trade environments|`Live environment`
+|`RequestTimeout`|The time out to use for requests.|`TimeSpan.FromSeconds(30)`|
+|`HttpClient`|The `HttpClient` instance to use for making requests. When creating multiple `RestClient` instances a single `HttpClient` should be provided to prevent each client instance from creating its own. *[WARNING] When providing the `HttpClient` instance in the options both the `RequestTimeout` and `Proxy` client options will be ignored and should be set on the provided `HttpClient` instance.*| `null` |
 
 **Socket client options (extension of base client options)**  
 
 |Option|Description|Default|
 |------|-----------|-------|
-|`AutoReconnect`|Whether or not the socket should attempt to automatically reconnect when disconnected.|`true`
+|`AutoReconnect`|Whether or not the socket should automatically reconnect when disconnected.|`true`
 |`ReconnectInterval`|The time to wait between connection tries when reconnecting.|`TimeSpan.FromSeconds(5)`
 |`SocketResponseTimeout`|The time in which a response is expected on a request before giving a timeout.|`TimeSpan.FromSeconds(10)`
 |`SocketNoDataTimeout`|If no data is received after this timespan then assume the connection is dropped. This is mainly used for API's which have some sort of ping/keepalive system. For example; the Bitfinex API will sent a heartbeat message every 15 seconds, so the `SocketNoDataTimeout` could be set to 20 seconds. On API's without such a mechanism this might not work because there just might not be any update while still being fully connected. | `default(TimeSpan)` (no timeout)
 |`SocketSubscriptionsCombineTarget`|The amount of subscriptions that should be made on a single socket connection. Not all exchanges support multiple subscriptions on a single socket. Setting this to a higher number increases subscription speed because not every subscription needs to connect to the server, but having more subscriptions on a single connection will also increase the amount of traffic on that single connection, potentially leading to issues.| Depends on implementation
+|`MaxReconnectTries`|The maximum amount of tries for reconnecting|`null` (infinite)
+|`MaxResubscribeTries`|The maximum amount of tries for resubscribing after successfully reconnecting the socket|5
 |`MaxConcurrentResubscriptionsPerSocket`|The maximum number of concurrent resubscriptions per socket when resubscribing after reconnecting|5
-|`MaxSocketConnections`|The maximum amount of distinct socket connections|`null`
-|`DelayAfterConnect`|The time to wait before sending messages after connecting to the server.|`TimeSpan.Zero`
-|`Environment`|The environment the library should talk to. Some exchanges have testnet/sandbox environments which can be used instead of the real exchange. The environment option can be used to switch between different trade environments|`Live environment`
 
 **Base Api client options**  
 
 |Option|Description|Default|
 |------|-----------|-------|
-|`ApiCredentials`|If set to `true` the originally received Json data will be output as well as the deserialized object. For `RestClient` calls the data will be in the `WebCallResult<T>.OriginalData` property, for `SocketClient` subscriptions the data will be available in the `DataEvent<T>.OriginalData` property when receiving an update. Overrides the Base client options `OutputOriginalData` option if set| `false`
-|`OutputOriginalData`|The base address to the API. All calls to the API will use this base address as basis for the endpoints. This allows for swapping to test API's or swapping to a different cluster for example. Available base addresses are defined in the [Library]ApiAddresses helper class, for example `KucoinApiAddresses`|Depends on implementation
+|`ApiCredentials`|The API credentials to use for this specific API client. Will override any credentials provided in the base client options|
+|`BaseAddress`|The base address to the API. All calls to the API will use this base address as basis for the endpoints. This allows for swapping to test API's or swapping to a different cluster for example. Available base addresses are defined in the [Library]ApiAddresses helper class, for example `KucoinApiAddresses`|Depends on implementation
 
 **Options for Rest Api Client (extension of base api client options)**  
 
@@ -113,21 +117,6 @@ All clients have access to the following options, specific implementations might
 |------|-----------|-------|
 |`RateLimiters`|A list of `IRateLimiter`s to use.|`new List<IRateLimiter>()`|
 |`RateLimitingBehaviour`|What should happen when a rate limit is reached.|`RateLimitingBehaviour.Wait`|
-|`AutoTimestamp`|Whether or not the library should attempt to sync the time between the client and server. If the time between server and client is not in sync authentication errors might occur. This option should be disabled when the client time sure to be in sync. Overrides the Rest client options `AutoTimestamp` option if set|`null`|
-|`TimestampRecalculationInterval`|The interval of how often the time synchronization between client and server should be executed. Overrides the Rest client options `TimestampRecalculationInterval` option if set| `TimeSpan.FromHours(1)`
 
 **Options for Socket Api Client (extension of base api client options)**  
-
-|Option|Description|Default|
-|------|-----------|-------|
-|`SocketNoDataTimeout`|If no data is received after this timespan then assume the connection is dropped. This is mainly used for API's which have some sort of ping/keepalive system. For example; the Bitfinex API will sent a heartbeat message every 15 seconds, so the `SocketNoDataTimeout` could be set to 20 seconds. On API's without such a mechanism this might not work because there just might not be any update while still being fully connected. Overrides the Socket client options `SocketNoDataTimeout` option if set | `default(TimeSpan)` (no timeout)
-|`MaxSocketConnections`|The maximum amount of distinct socket connections. Overrides the Socket client options `MaxSocketConnections` option if set |`null`
-
-## Credentials
-Credentials are supported in 3 formats in the base library:  
-
-|Type|Description|Example|
-|----|-----------|-------|
-|`Hmac`|An API key + secret combination. The API key is send with the request and the secret is used to sign requests. This is the default authentication method on all exchanges. |`options.ApiCredentials = new ApiCredentials("51231f76e-9c503548-8fabs3f-rfgf12mkl3", "556be32-d563ba53-faa2dfd-b3n5c", CredentialType.Hmac);`|
-|`RsaPem`|An API key + a public and private key pair generated by the user. The public key is shared with the exchange, while the private key is used to sign requests. This CredentialType expects the private key to be in .pem format and is only supported in .netstandard2.1 due to limitations of the framework|`options.ApiCredentials = new ApiCredentials("432vpV8daAaXAF4Qg", ""-----BEGIN PRIVATE KEY-----[PRIVATEKEY]-----END PRIVATE KEY-----", CredentialType.RsaPem);`|
-|`RsaXml`|An API key + a public and private key pair generated by the user. The public key is shared with the exchange, while the private key is used to sign requests. This CredentialType expects the private key to be in xml format and is supported in .netstandard2.0 and .netstandard2.1, but it might mean the private key needs to be converted from the original format to xml|`options.ApiCredentials = new ApiCredentials("432vpV8daAaXAF4Qg", "<RSAKeyValue>[PRIVATEKEY]</RSAKeyValue>", CredentialType.RsaXml);`|
+There are currently no specific options for socket API clients, the base API options are still available.

docs/Orderbooks.md

@@ -4,11 +4,11 @@ nav_order: 6
 ---
 
 ## Locally synced order book
-Each exchange implementation provides an order book implementation. These implementations will provide a client side order book and will take care of synchronization with the server, and will handle reconnecting and resynchronizing in case of a dropped connection.
+Each implementation provides an order book implementation. These implementations will provide a client side order book and will take care of synchronization with the server, and will handle reconnecting and resynchronizing in case of a dropped connection.
 Order book implementations are named as `[ExchangeName][Type]SymbolOrderBook`, for example `BinanceSpotSymbolOrderBook`. 
 
 ## Usage
-Start the book synchronization by calling the `StartAsync` method. This returns whether the book is successfully synchronized and started. You can listen to the `OnStatusChange` event to be notified of when the status of a book changes. Note that the order book is only synchronized with the server when the state is `Synced`. When the order book has been started and the state changes from `Synced` to `Reconnecting` the book will automatically reconnect and resync itself.
+Start the book synchronization by calling the `StartAsync` method. This returns a success state whether the book is successfully synchronized and started. You can listen to the `OnStatusChange` event to be notified of when the status of a book changes. Note that the order book is only synchronized with the server when the state is `Synced`.
 
 *Start an order book and print the top 3 rows*
 ```csharp
@@ -18,15 +18,14 @@ book.OnStatusChange += (oldState, newState) => Console.WriteLine($"State changed
 var startResult = await book.StartAsync();
 if (!startResult.Success)
 {
-    Console.WriteLine("Failed to start order book: " + startResult.Error);
-    return;
+	Console.WriteLine("Failed to start order book: " + startResult.Error);
+	return;
 }
 
 while(true)
 {
-    Console.Clear();
-    Console.WriteLine(book.ToString(3);
-    await Task.Delay(500);
+	Console.WriteLine(book.ToString(3);
+	await Task.Delay(500);
 }
 
 ```
@@ -55,14 +54,4 @@ book.OnStatusChange += (oldStatus, newStatus) => { Console.WriteLine($"State cha
 book.OnOrderBookUpdate += (bidsAsks) => { Console.WriteLine($"Order book changed: {bidsAsks.Asks.Count()} asks, {bidsAsks.Bids.Count()} bids"); };
 book.OnBestOffersChanged += (bestOffer) => { Console.WriteLine($"Best offer changed, best bid: {bestOffer.BestBid.Price}, best ask: {bestOffer.BestAsk.Price}"); };
 
-```
-
-### Order book factory
- Each exchange implementation also provides an order book factory for creating ISymbolOrderBook instances. The naming convention for the factory is `[Exchange]OrderBookFactory`, for example `BinanceOrderBookFactory`. This type will be automatically added when using DI and can be used to facilitate easier testing.
- 
- *Creating an order book using the order book factory*
- ```csharp
-var factory = services.GetRequiredService<IKucoinOrderBookFactory>();
-var book = factory.CreateSpot("ETH-USDT");
-var startResult = await book.StartAsync();
- ```
+```

docs/RateLimiter.md

@@ -1,6 +1,6 @@
 ---
 title: Rate limiting
-nav_order: 9
+nav_order: 7
 ---
 
 ## Rate limiting
@@ -13,12 +13,12 @@ A rate limiter can be configured in the options like so:
 ```csharp
 new ClientOptions
 {
-    RateLimitingBehaviour = RateLimitingBehaviour.Wait,
-    RateLimiters = new List<IRateLimiter>
-    {
-        new RateLimiter()
-            .AddTotalRateLimit(50, TimeSpan.FromSeconds(10))
-    }
+	RateLimitingBehaviour = RateLimitingBehaviour.Wait,
+	RateLimiters = new List<IRateLimiter>
+	{
+		new RateLimiter()
+			.AddTotalRateLimit(50, TimeSpan.FromSeconds(10))
+	}
 }
 ```
 
@@ -26,8 +26,8 @@ This will add a rate limiter for 50 requests per 10 seconds.
 A rate limiter can have multiple limits:
 ```csharp
 new RateLimiter()
-            .AddTotalRateLimit(50, TimeSpan.FromSeconds(10))
-            .AddEndpointLimit("/api/order", 10, TimeSpan.FromSeconds(2))
+			.AddTotalRateLimit(50, TimeSpan.FromSeconds(10))
+			.AddEndpointLimit("/api/order", 10, TimeSpan.FromSeconds(2))
 ```
 This adds another limit of 10 requests per 2 seconds in addition to the 50 requests per 10 seconds limit.
 These are the available rate limit configurations:

docs/index.md

@@ -3,7 +3,7 @@ title: Home
 nav_order: 1
 ---
 
-[![.NET](https://github.com/JKorf/CryptoExchange.Net/actions/workflows/dotnet.yml/badge.svg?branch=master)](https://github.com/JKorf/CryptoExchange.Net/actions/workflows/dotnet.yml) [![Nuget version](https://img.shields.io/nuget/v/CryptoExchange.Net.svg)](https://www.nuget.org/packages/CryptoExchange.Net)  [![Nuget downloads](https://img.shields.io/nuget/dt/CryptoExchange.Net.svg)](https://www.nuget.org/packages/CryptoExchange.Net)
+[![.NET](https://github.com/JKorf/CryptoExchange.Net/actions/workflows/dotnet.yml/badge.svg?branch=master)](https://github.com/JKorf/CryptoExchange.Net/actions/workflows/dotnet.yml) ![Nuget version](https://img.shields.io/nuget/v/CryptoExchange.Net.svg)  ![Nuget downloads](https://img.shields.io/nuget/dt/CryptoExchange.Net.svg)
 
 The CryptoExchange.Net library is a base package for exchange API implementations. It offers base classes for creating clients for exchange API's. Basing exchange implementation on the common CryptoExchange.Net library allows for ease of implementation for new exchanges, as only the endpoints and models have to implemented, but not all systems around requests and connections, and it makes it easier for users to implement a new library in their code base as all base principles and configuration are the same for different exchanges.
 
@@ -17,10 +17,10 @@ These will always be on the latest CryptoExchange.Net version and the latest ver
 |<a href="https://github.com/JKorf/Bittrex.Net"><img src="https://github.com/JKorf/Bittrex.Net/blob/master/Bittrex.Net/Icon/icon.png?raw=true"></a>|Bittrex|https://jkorf.github.io/Bittrex.Net/|
 |<a href="https://github.com/JKorf/Bybit.Net"><img src="https://github.com/JKorf/Bybit.Net/blob/main/ByBit.Net/Icon/icon.png?raw=true"></a>|Bybit|https://jkorf.github.io/Bybit.Net/|
 |<a href="https://github.com/JKorf/CoinEx.Net"><img src="https://github.com/JKorf/CoinEx.Net/blob/master/CoinEx.Net/Icon/icon.png?raw=true"></a>|CoinEx|https://jkorf.github.io/CoinEx.Net/|
+|<a href="https://github.com/JKorf/FTX.Net"><img src="https://github.com/JKorf/FTX.Net/blob/main/FTX.Net/Icon/icon.png?raw=true"></a>|FTX|https://jkorf.github.io/FTX.Net/|
 |<a href="https://github.com/JKorf/Huobi.Net"><img src="https://github.com/JKorf/Huobi.Net/blob/master/Huobi.Net/Icon/icon.png?raw=true"></a>|Huobi|https://jkorf.github.io/Huobi.Net/|
 |<a href="https://github.com/JKorf/Kraken.Net"><img src="https://github.com/JKorf/Kraken.Net/blob/master/Kraken.Net/Icon/icon.png?raw=true"></a>|Kraken|https://jkorf.github.io/Kraken.Net/|
 |<a href="https://github.com/JKorf/Kucoin.Net"><img src="https://github.com/JKorf/Kucoin.Net/blob/master/Kucoin.Net/Icon/icon.png?raw=true"></a>|Kucoin|https://jkorf.github.io/Kucoin.Net/|
-|<a href="https://github.com/JKorf/OKX.Net"><img src="https://raw.githubusercontent.com/JKorf/OKX.Net/358d31f58d8ee51fc234bff1940878a8d0ce5676/Okex.Net/Icon/icon.png"></a>|OKX|https://jkorf.github.io/OKX.Net/|
 
 **Implementations by third parties**  
 These might not be compatible with other libraries, make sure to check the CryptoExchange.Net version.  
@@ -32,6 +32,7 @@ These might not be compatible with other libraries, make sure to check the Crypt
 |<a href="https://github.com/ridicoulous/Bitmex.Net"><img src="https://github.com/ridicoulous/Bitmex.Net/blob/master/Bitmex.Net/Icon/icon.png?raw=true"></a>|Bitmex|
 |<a href="https://github.com/intelligences/HitBTC.Net"><img src="https://github.com/intelligences/HitBTC.Net/blob/master/src/HitBTC.Net/Icon/icon.png?raw=true"></a>|HitBTC|
 |<a href="https://github.com/EricGarnier/LiveCoin.Net"><img src="https://github.com/EricGarnier/LiveCoin.Net/blob/master/LiveCoin.Net/Icon/icon.png?raw=true"></a>|LiveCoin|
+|<a href="https://github.com/burakoner/OKEx.Net"><img src="https://github.com/burakoner/OKEx.Net/blob/master/Okex.Net/Icon/icon.png?raw=true"></a>|OKEx|
 |<a href="https://github.com/burakoner/Chiliz.Net"><img src="https://github.com/burakoner/Chiliz.Net/blob/master/Chiliz.Net/Icon/icon.png?raw=true"></a>|Chiliz|
 |<a href="https://github.com/burakoner/BtcTurk.Net"><img src="https://github.com/burakoner/BtcTurk.Net/blob/master/BtcTurk.Net/Icon/icon.png?raw=true"></a>|BtcTurk|
 |<a href="https://github.com/burakoner/Thodex.Net"><img src="https://github.com/burakoner/Thodex.Net/blob/master/Thodex.Net/Icon/icon.png?raw=true"></a>|Thodex|
@@ -41,24 +42,11 @@ These might not be compatible with other libraries, make sure to check the Crypt
 ## Discord
 A Discord server is available [here](https://discord.gg/MSpeEtSY8t). Feel free to join for discussion and/or questions around the CryptoExchange.Net and implementation libraries.
 
-## Support the project
-I develop and maintain this package on my own for free in my spare time, any support is greatly appreciated.
+## Donate / Sponsor
+I develop and maintain this package on my own for free in my spare time. Donations are greatly appreciated. If you prefer to donate any other currency please contact me.
 
-### Referral link
-Use one of the following following referral links to signup to a new exchange to pay a small percentage of the trading fees you pay to support the project instead of paying them straight to the exchange. This doesn't cost you a thing!
-[Binance](https://accounts.binance.com/en/register?ref=10153680)  
-[Bitfinex](https://www.bitfinex.com/sign-up?refcode=kCCe-CNBO)  
-[Bittrex](https://bittrex.com/discover/join?referralCode=TST-DJM-CSX)  
-[Bybit](https://partner.bybit.com/b/jkorf)  
-[CoinEx](https://www.coinex.com/register?refer_code=hd6gn)  
-[Huobi](https://www.huobi.com/en-us/v/register/double-invite/?inviter_id=11343840&invite_code=fxp93)  
-[Kucoin](https://www.kucoin.com/ucenter/signup?rcode=RguMux)  
+**Btc**:  12KwZk3r2Y3JZ2uMULcjqqBvXmpDwjhhQS  
+**Eth**:  0x069176ca1a4b1d6e0b7901a6bc0dbf3bb0bf5cc2  
+**Nano**: xrb_1ocs3hbp561ef76eoctjwg85w5ugr8wgimkj8mfhoyqbx4s1pbc74zggw7gs  
 
-### Donate
-Make a one time donation in a crypto currency of your choice. If you prefer to donate a currency not listed here please contact me.
-
-**Btc**:  bc1qz0jv0my7fc60rxeupr23e75x95qmlq6489n8gh  
-**Eth**:  0x8E21C4d955975cB645589745ac0c46ECA8FAE504  
-
-### Sponsor
-Alternatively, sponsor me on Github using [Github Sponsors](https://github.com/sponsors/JKorf). 
+Alternatively, sponsor me on Github using [Github Sponsors](https://github.com/sponsors/JKorf)