Feature/body uri param split (#203)

* Added support for specifying seperate uri and body parameters
* Added support for different message and handling generic types on socket queries
* Split DataEvent.Topic into StreamId and Symbol properties
* Added support for negative time values parsing
* Added some helper methods for converting DataEvent to CallResult
* Added support for GZip/Deflate automatic decompressing in the default HttpClient
* Updated some testing methods

CryptoExchange.Net.UnitTests/RestClientTests.cs

@@ -13,6 +13,11 @@ using System.Net.Http;
 using System.Threading.Tasks;
 using System.Threading;
 using NUnit.Framework.Legacy;
+using CryptoExchange.Net.RateLimiting;
+using System.Net;
+using CryptoExchange.Net.RateLimiting.Guards;
+using CryptoExchange.Net.RateLimiting.Filters;
+using CryptoExchange.Net.RateLimiting.Interfaces;
 
 namespace CryptoExchange.Net.UnitTests
 {
@@ -107,14 +112,14 @@ namespace CryptoExchange.Net.UnitTests
             // arrange
             // act
             var options = new TestClientOptions();
-            options.Api1Options.RateLimiters = new List<IRateLimiter> { new RateLimiter() };
+            options.Api1Options.TimestampRecalculationInterval = TimeSpan.FromMinutes(10);
-            options.Api1Options.RateLimitingBehaviour = RateLimitingBehaviour.Fail;
+            options.Api1Options.OutputOriginalData = true;
             options.RequestTimeout = TimeSpan.FromMinutes(1);
             var client = new TestBaseClient(options);
 
             // assert
-            Assert.That(((TestClientOptions)client.ClientOptions).Api1Options.RateLimiters.Count == 1);
+            Assert.That(((TestClientOptions)client.ClientOptions).Api1Options.TimestampRecalculationInterval == TimeSpan.FromMinutes(10));
-            Assert.That(((TestClientOptions)client.ClientOptions).Api1Options.RateLimitingBehaviour == RateLimitingBehaviour.Fail);
+            Assert.That(((TestClientOptions)client.ClientOptions).Api1Options.OutputOriginalData == true);
             Assert.That(((TestClientOptions)client.ClientOptions).RequestTimeout == TimeSpan.FromMinutes(1));
         }
 
@@ -162,18 +167,22 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase(1, 2)]
         public async Task PartialEndpointRateLimiterBasics(int requests, double perSeconds)
         {
-            var rateLimiter = new RateLimiter();
+            var rateLimiter = new RateLimitGate("Test");
-            rateLimiter.AddPartialEndpointLimit("/sapi/", requests, TimeSpan.FromSeconds(perSeconds));
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, new PathStartFilter("/sapi/"), requests, TimeSpan.FromSeconds(perSeconds), RateLimitWindowType.Fixed));
+
+            var triggered = false;
+            rateLimiter.RateLimitTriggered += (x) => { triggered = true; };
+            var requestDefinition = new RequestDefinition("/sapi/v1/system/status", HttpMethod.Get);
 
             for (var i = 0; i < requests + 1; i++)
             {
-                var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), "/sapi/v1/system/status", HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);             
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);             
-                Assert.That(i == requests? result1.Data > 1 : result1.Data == 0);
+                Assert.That(i == requests? triggered : !triggered);
             }
-
+            triggered = false;
             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.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1,  RateLimitingBehaviour.Wait, default);
-            Assert.That(result2.Data == 0);
+            Assert.That(!triggered);
         }
 
         [TestCase("/sapi/test1", true)]
@@ -183,29 +192,40 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase("/sapi/", true)]
         public async Task PartialEndpointRateLimiterEndpoints(string endpoint, bool expectLimiting)
         {
-            var rateLimiter = new RateLimiter();
+            var rateLimiter = new RateLimitGate("Test");
-            rateLimiter.AddPartialEndpointLimit("/sapi/", 1, TimeSpan.FromSeconds(0.1));
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, new PathStartFilter("/sapi/"), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
 
+            var requestDefinition = new RequestDefinition(endpoint, HttpMethod.Get);
+
+            RateLimitEvent evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
-                bool expected = i == 1 ? (expectLimiting ? result1.Data > 1 : result1.Data == 0) : result1.Data == 0; 
+                bool expected = i == 1 ? (expectLimiting ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
                 Assert.That(expected);
             }
         }
+
         [TestCase("/sapi/", "/sapi/", true)]
         [TestCase("/sapi/test", "/sapi/test", true)]
         [TestCase("/sapi/test", "/sapi/test123", false)]
         [TestCase("/sapi/test", "/sapi/", false)]
         public async Task PartialEndpointRateLimiterEndpoints(string endpoint1, string endpoint2, bool expectLimiting)
         {
-            var rateLimiter = new RateLimiter();
+            var rateLimiter = new RateLimitGate("Test");
-            rateLimiter.AddPartialEndpointLimit("/sapi/", 1, TimeSpan.FromSeconds(0.1), countPerEndpoint: true);
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerEndpoint, new PathStartFilter("/sapi/"), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
 
-            var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint1, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            var requestDefinition1 = new RequestDefinition(endpoint1, HttpMethod.Get);
-            var result2 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint2, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            var requestDefinition2 = new RequestDefinition(endpoint2, HttpMethod.Get);
-            Assert.That(result1.Data == 0);            
+
-            Assert.That(expectLimiting ? result2.Data > 0 : result2.Data == 0);            
+            RateLimitEvent evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
+
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(evnt == null);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(expectLimiting ? evnt != null : evnt == null);
         }
 
         [TestCase(1, 0.1)]
@@ -214,18 +234,22 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase(1, 2)]
         public async Task EndpointRateLimiterBasics(int requests, double perSeconds)
         {
-            var rateLimiter = new RateLimiter();
+            var rateLimiter = new RateLimitGate("Test");
-            rateLimiter.AddEndpointLimit("/sapi/test", requests, TimeSpan.FromSeconds(perSeconds));
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerEndpoint, new PathStartFilter("/sapi/test"), requests, TimeSpan.FromSeconds(perSeconds), RateLimitWindowType.Fixed));
+
+            bool triggered = false;
+            rateLimiter.RateLimitTriggered += (x) => { triggered = true; };
+            var requestDefinition = new RequestDefinition("/sapi/test", HttpMethod.Get);
 
             for (var i = 0; i < requests + 1; i++)
             {
-                var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), "/sapi/test", HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
-                Assert.That(i == requests ? result1.Data > 1 : result1.Data == 0);
+                Assert.That(i == requests ? triggered : !triggered);
             }
-
+            triggered = false;
             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.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
-            Assert.That(result2.Data == 0);
+            Assert.That(!triggered);
         }
 
         [TestCase("/", false)]
@@ -233,13 +257,17 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase("/sapi/test/123", false)]
         public async Task EndpointRateLimiterEndpoints(string endpoint, bool expectLimited)
         {
-            var rateLimiter = new RateLimiter();
+            var rateLimiter = new RateLimitGate("Test");
-            rateLimiter.AddEndpointLimit("/sapi/test", 1, TimeSpan.FromSeconds(0.1));
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerEndpoint, new ExactPathFilter("/sapi/test"), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
+            
+            var requestDefinition = new RequestDefinition(endpoint, HttpMethod.Get);
 
+            RateLimitEvent evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
-                bool expected = i == 1 ? (expectLimited ? result1.Data > 1 : result1.Data == 0) : result1.Data == 0; 
+                bool expected = i == 1 ? (expectLimited ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
                 Assert.That(expected);
             }
         }
@@ -250,47 +278,41 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase("/sapi/test23", false)]
         public async Task EndpointRateLimiterMultipleEndpoints(string endpoint, bool expectLimited)
         {
-            var rateLimiter = new RateLimiter();
+            var rateLimiter = new RateLimitGate("Test");
-            rateLimiter.AddEndpointLimit(new[] { "/sapi/test", "/sapi/test2" }, 1, TimeSpan.FromSeconds(0.1));
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerEndpoint, new ExactPathsFilter(new[] { "/sapi/test", "/sapi/test2" }), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
+            var requestDefinition = new RequestDefinition(endpoint, HttpMethod.Get);
 
+            RateLimitEvent evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
-                bool expected = i == 1 ? (expectLimited ? result1.Data > 1 : result1.Data == 0) : result1.Data == 0;
+                bool expected = i == 1 ? (expectLimited ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
                 Assert.That(expected);
             }
         }
 
-        [TestCase("123", "123", "/sapi/test", "/sapi/test", true, true, true, true)]
+        [TestCase("123", "123", "/sapi/test", "/sapi/test", true)]
-        [TestCase("123", "456", "/sapi/test", "/sapi/test", true, true, true, false)]
+        [TestCase("123", "456", "/sapi/test", "/sapi/test", false)]
-        [TestCase("123", "123", "/sapi/test", "/sapi/test2", true, true, true, true)]
+        [TestCase("123", "123", "/sapi/test", "/sapi/test2", true)]
-        [TestCase("123", "123", "/sapi/test2", "/sapi/test", true, true, true, true)]
+        [TestCase("123", "123", "/sapi/test2", "/sapi/test", true)]
-        [TestCase("123", "123", "/sapi/test", "/sapi/test", true, false, true, false)]
+        [TestCase(null, "123", "/sapi/test", "/sapi/test", false)]
-        [TestCase("123", "123", "/sapi/test", "/sapi/test", false, true, true, false)]
+        [TestCase("123", null, "/sapi/test", "/sapi/test", false)]
-        [TestCase("123", "123", "/sapi/test", "/sapi/test", false, false, true, false)]
+        [TestCase(null, null, "/sapi/test", "/sapi/test", false)]
-        [TestCase(null, "123", "/sapi/test", "/sapi/test", false, true, true, false)]
+        public async Task ApiKeyRateLimiterBasics(string key1, string key2, string endpoint1, string endpoint2, bool expectLimited)
-        [TestCase("123", null, "/sapi/test", "/sapi/test", true, false, true, false)]
-        [TestCase(null, null, "/sapi/test", "/sapi/test", false, false, true, false)]
-
-        [TestCase("123", "123", "/sapi/test", "/sapi/test", true, true, false, true)]
-        [TestCase("123", "456", "/sapi/test", "/sapi/test", true, true, false, false)]
-        [TestCase("123", "123", "/sapi/test", "/sapi/test2", true, true, false, true)]
-        [TestCase("123", "123", "/sapi/test2", "/sapi/test", true, true, false, true)]
-        [TestCase("123", "123", "/sapi/test", "/sapi/test", true, false, false, true)]
-        [TestCase("123", "123", "/sapi/test", "/sapi/test", false, true, false, true)]
-        [TestCase("123", "123", "/sapi/test", "/sapi/test", false, false, false, true)]
-        [TestCase(null, "123", "/sapi/test", "/sapi/test", false, true, false, false)]
-        [TestCase("123", null, "/sapi/test", "/sapi/test", true, false, false, false)]
-        [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 rateLimiter = new RateLimiter();
+            var rateLimiter = new RateLimitGate("Test");
-            rateLimiter.AddApiKeyLimit(1, TimeSpan.FromSeconds(0.1), onlyForSignedRequests, false);
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerApiKey, new AuthenticatedEndpointFilter(true), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
+            var requestDefinition1 = new RequestDefinition(endpoint1, HttpMethod.Get) { Authenticated = key1 != null };
+            var requestDefinition2 = new RequestDefinition(endpoint2, HttpMethod.Get) { Authenticated = key2 != null };
 
-            var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint1, HttpMethod.Get, signed1, key1?.ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            RateLimitEvent evnt = null;
-            var result2 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint2, HttpMethod.Get, signed2, key2?.ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
-            Assert.That(result1.Data == 0);
+
-            Assert.That(expectLimited ? result2.Data > 0 : result2.Data == 0);            
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", key1?.ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(evnt == null);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", key2?.ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(expectLimited ? evnt != null : evnt == null);
         }
 
         [TestCase("/sapi/test", "/sapi/test", true)]
@@ -298,29 +320,55 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase("/", "/sapi/test2", true)]
         public async Task TotalRateLimiterBasics(string endpoint1, string endpoint2, bool expectLimited)
         {
-            var rateLimiter = new RateLimiter();
+            var rateLimiter = new RateLimitGate("Test");
-            rateLimiter.AddTotalRateLimit(1, TimeSpan.FromSeconds(0.1));
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, Array.Empty<IGuardFilter>(), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
+            var requestDefinition1 = new RequestDefinition(endpoint1, HttpMethod.Get);
+            var requestDefinition2 = new RequestDefinition(endpoint2, HttpMethod.Get) { Authenticated = true };
 
-            var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint1, HttpMethod.Get, false, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            RateLimitEvent evnt = null;
-            var result2 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint2, HttpMethod.Get, true, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
-            Assert.That(result1.Data == 0);
+
-            Assert.That(expectLimited ? result2.Data > 0 : result2.Data == 0);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(evnt == null);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", null, 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(expectLimited ? evnt != null : evnt == null);
         }
 
-        [TestCase("/sapi/test", true, true, true, false)]
+        [TestCase("https://test.com", "/sapi/test", "https://test.com", "/sapi/test", true)]
-        [TestCase("/sapi/test", false, true, true, false)]
+        [TestCase("https://test2.com", "/sapi/test", "https://test.com", "/sapi/test", false)]
-        [TestCase("/sapi/test", false, true, false, true)]
+        [TestCase("https://test.com", "/sapi/test", "https://test2.com", "/sapi/test", false)]
-        [TestCase("/sapi/test", true, true, false, true)]
+        [TestCase("https://test.com", "/sapi/test", "https://test.com", "/sapi/test2", true)]
-        public async Task ApiKeyRateLimiterIgnores_TotalRateLimiter_IfSet(string endpoint, bool signed1, bool signed2, bool ignoreTotal, bool expectLimited)
+        public async Task HostRateLimiterBasics(string host1, string endpoint1, string host2, string endpoint2, bool expectLimited)
         {
-            var rateLimiter = new RateLimiter();
+            var rateLimiter = new RateLimitGate("Test");
-            rateLimiter.AddApiKeyLimit(100, TimeSpan.FromSeconds(0.1), true, ignoreTotal);
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, new HostFilter("https://test.com"), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
-            rateLimiter.AddTotalRateLimit(1, TimeSpan.FromSeconds(0.1));
+            var requestDefinition1 = new RequestDefinition(endpoint1, HttpMethod.Get);
+            var requestDefinition2 = new RequestDefinition(endpoint2, HttpMethod.Get) { Authenticated = true };
 
-            var result1 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint, HttpMethod.Get, signed1, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            RateLimitEvent evnt = null;
-            var result2 = await rateLimiter.LimitRequestAsync(new TraceLogger(), endpoint, HttpMethod.Get, signed2, "123".ToSecureString(), RateLimitingBehaviour.Wait, 1, default);
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
-            Assert.That(result1.Data == 0);
+
-            Assert.That(expectLimited ? result2.Data > 0 : result2.Data == 0);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, host1, "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(evnt == null);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, host2, "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(expectLimited ? evnt != null : evnt == null);
+        }
+
+        [TestCase("https://test.com", "https://test.com", true)]
+        [TestCase("https://test2.com", "https://test.com", false)]
+        [TestCase("https://test.com", "https://test2.com", false)]
+        public async Task ConnectionRateLimiterBasics(string host1, string host2, bool expectLimited)
+        {
+            var rateLimiter = new RateLimitGate("Test");
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, new LimitItemTypeFilter(RateLimitItemType.Connection), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
+
+            RateLimitEvent evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
+
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), host1, "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(evnt == null);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), host2, "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            Assert.That(expectLimited ? evnt != null : evnt == null);
         }
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/TestBaseClient.cs

@@ -54,6 +54,8 @@ namespace CryptoExchange.Net.UnitTests
             return deserializeResult;
         }
 
+        /// <inheritdoc />
+        public override string FormatSymbol(string baseAsset, string quoteAsset) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
         public override TimeSpan? GetTimeOffset() => null;
         public override TimeSyncInfo GetTimeSyncInfo() => null;
         protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials) => throw new NotImplementedException();
@@ -66,11 +68,8 @@ namespace CryptoExchange.Net.UnitTests
         {
         }
 
-        public override void AuthenticateRequest(RestApiClient apiClient, Uri uri, HttpMethod method, Dictionary<string, object> providedParameters, bool auth, ArrayParametersSerialization arraySerialization, HttpMethodParameterPosition parameterPosition, RequestBodyFormat bodyFormat, out SortedDictionary<string, object> uriParameters, out SortedDictionary<string, object> bodyParameters, out Dictionary<string, string> headers)
+        public override void AuthenticateRequest(RestApiClient apiClient, Uri uri, HttpMethod method, IDictionary<string, object> uriParams, IDictionary<string, object> bodyParams, Dictionary<string, string> headers, bool auth, ArrayParametersSerialization arraySerialization, HttpMethodParameterPosition parameterPosition, RequestBodyFormat bodyFormat)
         {
-            bodyParameters = new SortedDictionary<string, object>();
-            uriParameters = new SortedDictionary<string, object>();
-            headers = new Dictionary<string, string>();
         }
 
         public string GetKey() => _credentials.Key.GetString();

CryptoExchange.Net.UnitTests/TestImplementations/TestRestClient.cs

@@ -137,14 +137,17 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             RequestFactory = new Mock<IRequestFactory>().Object;
         }
 
+        /// <inheritdoc />
+        public override string FormatSymbol(string baseAsset, string quoteAsset) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
+
         public async Task<CallResult<T>> Request<T>(CancellationToken ct = default) where T : class
         {
-            return await SendRequestAsync<T>(new Uri("http://www.test.com"), HttpMethod.Get, ct);
+            return await SendRequestAsync<T>(new Uri("http://www.test.com"), HttpMethod.Get, ct, requestWeight: 0);
         }
 
         public async Task<CallResult<T>> RequestWithParams<T>(HttpMethod method, Dictionary<string, object> parameters, Dictionary<string, string> headers) where T : class
         {
-            return await SendRequestAsync<T>(new Uri("http://www.test.com"), method, default, parameters, additionalHeaders: headers);
+            return await SendRequestAsync<T>(new Uri("http://www.test.com"), method, default, parameters, requestWeight: 0, additionalHeaders: headers);
         }
 
         public void SetParameterPosition(HttpMethod method, HttpMethodParameterPosition position)
@@ -178,9 +181,12 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             RequestFactory = new Mock<IRequestFactory>().Object;
         }
 
+        /// <inheritdoc />
+        public override string FormatSymbol(string baseAsset, string quoteAsset) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
+
         public async Task<CallResult<T>> Request<T>(CancellationToken ct = default) where T : class
         {
-            return await SendRequestAsync<T>(new Uri("http://www.test.com"), HttpMethod.Get, ct);
+            return await SendRequestAsync<T>(new Uri("http://www.test.com"), HttpMethod.Get, ct, requestWeight: 0);
         }
 
         protected override Error ParseErrorResponse(int httpStatusCode, IEnumerable<KeyValuePair<string, IEnumerable<string>>> responseHeaders, IMessageAccessor accessor)

CryptoExchange.Net.UnitTests/TestImplementations/TestSocket.cs

@@ -18,6 +18,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
 #pragma warning disable 0067
         public event Func<Task> OnReconnected;
         public event Func<Task> OnReconnecting;
+        public event Func<int, Task> OnRequestRateLimited;
 #pragma warning restore 0067
         public event Func<int, Task> OnRequestSent;
         public event Action<WebSocketMessageType, ReadOnlyMemory<byte>> OnStreamMessage;
@@ -62,13 +63,13 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             }
         }
 
-        public Task<bool> ConnectAsync()
+        public Task<CallResult> ConnectAsync()
         {
             Connected = CanConnect;
             ConnectCalls++;
             if (CanConnect)
                 InvokeOpen();
-            return Task.FromResult(CanConnect);
+            return Task.FromResult(CanConnect ? new CallResult(null) : new CallResult(new CantConnectError()));
         }
 
         public void Send(int requestId, string data, int weight)

CryptoExchange.Net.UnitTests/TestImplementations/TestSocketClient.cs

@@ -84,6 +84,9 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
 
         }
 
+        /// <inheritdoc />
+        public override string FormatSymbol(string baseAsset, string quoteAsset) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
+
         internal IWebsocket CreateSocketInternal(string address)
         {
             return CreateSocket(address);
@@ -92,7 +95,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
         protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials)
             => new TestAuthProvider(credentials);
 
-        public CallResult<bool> ConnectSocketSub(SocketConnection sub)
+        public CallResult ConnectSocketSub(SocketConnection sub)
         {
             return ConnectSocketAsync(sub).Result;
         }

CryptoExchange.Net/Authentication/AuthenticationProvider.cs

@@ -1,5 +1,6 @@
 using CryptoExchange.Net.Clients;
 using CryptoExchange.Net.Converters.SystemTextJson;
+using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
 using System;
 using System.Collections.Generic;
@@ -15,10 +16,12 @@ namespace CryptoExchange.Net.Authentication
     /// </summary>
     public abstract class AuthenticationProvider : IDisposable
     {
+        internal IAuthTimeProvider TimeProvider { get; set; } = new AuthTimeProvider();
+
         /// <summary>
         /// Provided credentials
         /// </summary>
-        protected readonly ApiCredentials _credentials;
+        protected internal readonly ApiCredentials _credentials;
 
         /// <summary>
         /// Byte representation of the secret
@@ -44,26 +47,24 @@ namespace CryptoExchange.Net.Authentication
         /// <param name="apiClient">The Api client sending the request</param>
         /// <param name="uri">The uri for the request</param>
         /// <param name="method">The method of the request</param>
-        /// <param name="providedParameters">The request parameters</param>
         /// <param name="auth">If the requests should be authenticated</param>
         /// <param name="arraySerialization">Array serialization type</param>
-        /// <param name="parameterPosition">The position where the providedParameters should go</param>
         /// <param name="requestBodyFormat">The formatting of the request body</param>
         /// <param name="uriParameters">Parameters that need to be in the Uri of the request. Should include the provided parameters if they should go in the uri</param>
         /// <param name="bodyParameters">Parameters that need to be in the body of the request. Should include the provided parameters if they should go in the body</param>
         /// <param name="headers">The headers that should be send with the request</param>
+        /// <param name="parameterPosition">The position where the providedParameters should go</param>
         public abstract void AuthenticateRequest(
             RestApiClient apiClient,
             Uri uri,
             HttpMethod method,
-            Dictionary<string, object> providedParameters,
+            IDictionary<string, object> uriParameters,
+            IDictionary<string, object> bodyParameters,
+            Dictionary<string, string> headers,
             bool auth,
             ArrayParametersSerialization arraySerialization,
             HttpMethodParameterPosition parameterPosition,
-            RequestBodyFormat requestBodyFormat,
+            RequestBodyFormat requestBodyFormat
-            out SortedDictionary<string, object> uriParameters,
-            out SortedDictionary<string, object> bodyParameters,
-            out Dictionary<string, string> headers
             );
 
         /// <summary>
@@ -418,9 +419,9 @@ namespace CryptoExchange.Net.Authentication
         /// </summary>
         /// <param name="apiClient"></param>
         /// <returns></returns>
-        protected static DateTime GetTimestamp(RestApiClient apiClient)
+        protected DateTime GetTimestamp(RestApiClient apiClient)
         {
-            return DateTime.UtcNow.Add(apiClient.GetTimeOffset() ?? TimeSpan.Zero)!;
+            return TimeProvider.GetTime().Add(apiClient.GetTimeOffset() ?? TimeSpan.Zero)!;
         }
 
         /// <summary>
@@ -428,11 +429,25 @@ namespace CryptoExchange.Net.Authentication
         /// </summary>
         /// <param name="apiClient"></param>
         /// <returns></returns>
-        protected static string GetMillisecondTimestamp(RestApiClient apiClient)
+        protected string GetMillisecondTimestamp(RestApiClient apiClient)
         {
             return DateTimeConverter.ConvertToMilliseconds(GetTimestamp(apiClient)).Value.ToString(CultureInfo.InvariantCulture);
         }
 
+        /// <summary>
+        /// Return the serialized request body
+        /// </summary>
+        /// <param name="serializer"></param>
+        /// <param name="parameters"></param>
+        /// <returns></returns>
+        protected string GetSerializedBody(IMessageSerializer serializer, IDictionary<string, object> parameters)
+        {
+            if (parameters.Count == 1 && parameters.ContainsKey(Constants.BodyPlaceHolderKey))
+                return serializer.Serialize(parameters[Constants.BodyPlaceHolderKey]);
+            else
+                return serializer.Serialize(parameters);
+        }
+
         /// <inheritdoc />
         public void Dispose()
         {

CryptoExchange.Net/Clients/BaseApiClient.cs

@@ -1,13 +1,6 @@
 using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Net.Http;
-using System.Text;
-using System.Threading.Tasks;
 using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Converters;
 using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Options;
 using Microsoft.Extensions.Logging;
 
@@ -85,6 +78,9 @@ namespace CryptoExchange.Net.Clients
         /// <returns></returns>
         protected abstract AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials);
 
+        /// <inheritdoc />
+        public abstract string FormatSymbol(string baseAsset, string quoteAsset);
+
         /// <inheritdoc />
         public void SetApiCredentials<T>(T credentials) where T : ApiCredentials
         {

CryptoExchange.Net/Clients/BaseSocketClient.cs

@@ -108,5 +108,19 @@ namespace CryptoExchange.Net.Clients
             }
             return result.ToString();
         }
+
+        /// <summary>
+        /// Returns the state of all socket api clients
+        /// </summary>
+        /// <returns></returns>
+        public List<SocketApiClient.SocketApiClientState> GetSocketApiClientStates()
+        {
+            var result = new List<SocketApiClient.SocketApiClientState>();
+            foreach (var client in ApiClients.OfType<SocketApiClient>())
+            {
+                result.Add(client.GetState());
+            }
+            return result;
+        }
     }
 }

CryptoExchange.Net/Clients/RestApiClient.cs

@@ -13,6 +13,8 @@ using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Logging.Extensions;
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.RateLimiting;
+using CryptoExchange.Net.RateLimiting.Interfaces;
 using CryptoExchange.Net.Requests;
 using Microsoft.Extensions.Logging;
 
@@ -38,17 +40,17 @@ namespace CryptoExchange.Net.Clients
         /// <summary>
         /// Request body content type
         /// </summary>
-        protected RequestBodyFormat RequestBodyFormat = RequestBodyFormat.Json;
+        protected internal RequestBodyFormat RequestBodyFormat = RequestBodyFormat.Json;
 
         /// <summary>
         /// How to serialize array parameters when making requests
         /// </summary>
-        protected ArrayParametersSerialization ArraySerialization = ArrayParametersSerialization.Array;
+        protected internal ArrayParametersSerialization ArraySerialization = ArrayParametersSerialization.Array;
 
         /// <summary>
         /// What request body should be set when no data is send (only used in combination with postParametersPosition.InBody)
         /// </summary>
-        protected string RequestBodyEmptyContent = "{}";
+        protected internal string RequestBodyEmptyContent = "{}";
 
         /// <summary>
         /// Request headers to be sent with each request
@@ -56,9 +58,14 @@ namespace CryptoExchange.Net.Clients
         protected Dictionary<string, string>? StandardRequestHeaders { get; set; }
 
         /// <summary>
-        /// List of rate limiters
+        /// Whether parameters need to be ordered
         /// </summary>
-        internal IEnumerable<IRateLimiter> RateLimiters { get; }
+        protected internal bool OrderParameters { get; set; } = true;
+
+        /// <summary>
+        /// Parameter order comparer
+        /// </summary>
+        protected IComparer<string> ParameterOrderComparer { get; } = new OrderedStringComparer();
 
         /// <summary>
         /// Where to put the parameters for requests with different Http methods
@@ -68,7 +75,8 @@ namespace CryptoExchange.Net.Clients
             { HttpMethod.Get, HttpMethodParameterPosition.InUri },
             { HttpMethod.Post, HttpMethodParameterPosition.InBody },
             { HttpMethod.Delete, HttpMethodParameterPosition.InBody },
-            { HttpMethod.Put, HttpMethodParameterPosition.InBody }
+            { HttpMethod.Put, HttpMethodParameterPosition.InBody },
+            { new HttpMethod("Patch"), HttpMethodParameterPosition.InBody },
         };
 
         /// <inheritdoc />
@@ -94,11 +102,6 @@ namespace CryptoExchange.Net.Clients
                   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);
         }
 
@@ -114,6 +117,269 @@ namespace CryptoExchange.Net.Clients
         /// <returns></returns>
         protected virtual IMessageSerializer CreateSerializer() => new JsonNetMessageSerializer();
 
+        /// <summary>
+        /// Send a request to the base address based on the request definition
+        /// </summary>
+        /// <param name="baseAddress">Host and schema</param>
+        /// <param name="definition">Request definition</param>
+        /// <param name="parameters">Request parameters</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <param name="additionalHeaders">Additional headers for this request</param>
+        /// <param name="weight">Override the request weight for this request definition, for example when the weight depends on the parameters</param>
+        /// <returns></returns>
+        protected virtual async Task<WebCallResult> SendAsync(
+            string baseAddress,
+            RequestDefinition definition,
+            ParameterCollection? parameters,
+            CancellationToken cancellationToken,
+            Dictionary<string, string>? additionalHeaders = null,
+            int? weight = null)
+        { 
+            var result = await SendAsync<object>(baseAddress, definition, parameters, cancellationToken, additionalHeaders, weight).ConfigureAwait(false);
+            return result.AsDataless();
+        }
+
+        /// <summary>
+        /// Send a request to the base address based on the request definition
+        /// </summary>
+        /// <typeparam name="T">Response type</typeparam>
+        /// <param name="baseAddress">Host and schema</param>
+        /// <param name="definition">Request definition</param>
+        /// <param name="parameters">Request parameters</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <param name="additionalHeaders">Additional headers for this request</param>
+        /// <param name="weight">Override the request weight for this request definition, for example when the weight depends on the parameters</param>
+        /// <returns></returns>
+        protected virtual Task<WebCallResult<T>> SendAsync<T>(
+            string baseAddress,
+            RequestDefinition definition,
+            ParameterCollection? parameters,
+            CancellationToken cancellationToken,
+            Dictionary<string, string>? additionalHeaders = null,
+            int? weight = null) where T : class
+        {
+            var parameterPosition = definition.ParameterPosition ?? ParameterPositions[definition.Method];
+            return SendAsync<T>(
+                baseAddress,
+                definition,
+                parameterPosition == HttpMethodParameterPosition.InUri ? parameters : null,
+                parameterPosition == HttpMethodParameterPosition.InBody ? parameters : null,
+                cancellationToken,
+                additionalHeaders,
+                weight);
+        }
+
+        /// <summary>
+        /// Send a request to the base address based on the request definition
+        /// </summary>
+        /// <typeparam name="T">Response type</typeparam>
+        /// <param name="baseAddress">Host and schema</param>
+        /// <param name="definition">Request definition</param>
+        /// <param name="uriParameters">Request query parameters</param>
+        /// <param name="bodyParameters">Request body parameters</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <param name="additionalHeaders">Additional headers for this request</param>
+        /// <param name="weight">Override the request weight for this request definition, for example when the weight depends on the parameters</param>
+        /// <returns></returns>
+        protected virtual async Task<WebCallResult<T>> SendAsync<T>(
+            string baseAddress,
+            RequestDefinition definition,
+            ParameterCollection? uriParameters,
+            ParameterCollection? bodyParameters,
+            CancellationToken cancellationToken,
+            Dictionary<string, string>? additionalHeaders = null,
+            int? weight = null) where T : class
+        {
+            int currentTry = 0;
+            while (true)
+            {
+                currentTry++;
+                var prepareResult = await PrepareAsync(baseAddress, definition, cancellationToken, additionalHeaders, weight).ConfigureAwait(false);
+                if (!prepareResult)
+                    return new WebCallResult<T>(prepareResult.Error!);
+
+                var request = CreateRequest(
+                    baseAddress,
+                    definition,
+                    uriParameters,
+                    bodyParameters,
+                    additionalHeaders);
+                _logger.RestApiSendRequest(request.RequestId, definition, request.Content, request.Uri.Query, string.Join(", ", request.GetHeaders().Select(h => h.Key + $"=[{string.Join(",", h.Value)}]")));
+                TotalRequestsMade++;
+                var result = await GetResponseAsync<T>(request, definition.RateLimitGate, cancellationToken).ConfigureAwait(false);
+                if (!result)
+                    _logger.RestApiErrorReceived(result.RequestId, result.ResponseStatusCode, (long)Math.Floor(result.ResponseTime!.Value.TotalMilliseconds), result.Error?.ToString());
+                else
+                    _logger.RestApiResponseReceived(result.RequestId, result.ResponseStatusCode, (long)Math.Floor(result.ResponseTime!.Value.TotalMilliseconds), OutputOriginalData ? result.OriginalData : "[Data only available when OutputOriginal = true]");
+
+                if (await ShouldRetryRequestAsync(definition.RateLimitGate, result, currentTry).ConfigureAwait(false))
+                    continue;
+
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// Prepare before sending a request. Sync time between client and server and check rate limits
+        /// </summary>
+        /// <param name="baseAddress">Host and schema</param>
+        /// <param name="definition">Request definition</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <param name="additionalHeaders">Additional headers for this request</param>
+        /// <param name="weight">Override the request weight for this request</param>
+        /// <returns></returns>
+        /// <exception cref="Exception"></exception>
+        protected virtual async Task<CallResult> PrepareAsync(
+            string baseAddress,
+            RequestDefinition definition,
+            CancellationToken cancellationToken,
+            Dictionary<string, string>? additionalHeaders = null,
+            int? weight = null)
+        {
+            var requestId = ExchangeHelpers.NextId();
+            var requestWeight = weight ?? definition.Weight;
+
+            // Time sync
+            if (definition.Authenticated)
+            {
+                if (AuthenticationProvider == null)
+                {
+                    _logger.RestApiNoApiCredentials(requestId, definition.Path);
+                    return new CallResult<IRequest>(new NoApiCredentialsError());
+                }
+
+                var syncTask = SyncTimeAsync();
+                var timeSyncInfo = GetTimeSyncInfo();
+
+                if (timeSyncInfo != null && timeSyncInfo.TimeSyncState.LastSyncTime == default)
+                {
+                    // Initially with first request we'll need to wait for the time syncing, if it's not the first request we can just continue
+                    var syncTimeResult = await syncTask.ConfigureAwait(false);
+                    if (!syncTimeResult)
+                    {
+                        _logger.RestApiFailedToSyncTime(requestId, syncTimeResult.Error!.ToString());
+                        return syncTimeResult.AsDataless();
+                    }
+                }
+            }            
+
+            // Rate limiting
+            if (requestWeight != 0)
+            {
+                if (definition.RateLimitGate == null)
+                    throw new Exception("Ratelimit gate not set when request weight is not 0");
+
+                if (ClientOptions.RateLimiterEnabled)
+                {
+                    var limitResult = await definition.RateLimitGate.ProcessAsync(_logger, requestId, RateLimitItemType.Request, definition, baseAddress, AuthenticationProvider?._credentials.Key, requestWeight, ClientOptions.RateLimitingBehaviour, cancellationToken).ConfigureAwait(false);
+                    if (!limitResult)
+                        return new CallResult(limitResult.Error!);
+                }
+            }
+
+            // Endpoint specific rate limiting
+            if (definition.EndpointLimitCount != null && definition.EndpointLimitPeriod != null)
+            {
+                if (definition.RateLimitGate == null)
+                    throw new Exception("Ratelimit gate not set when endpoint limit is specified");
+
+                if (ClientOptions.RateLimiterEnabled)
+                {
+                    var limitResult = await definition.RateLimitGate.ProcessSingleAsync(_logger, requestId, RateLimitItemType.Request, definition, baseAddress, AuthenticationProvider?._credentials.Key, requestWeight, ClientOptions.RateLimitingBehaviour, cancellationToken).ConfigureAwait(false);
+                    if (!limitResult)
+                        return new CallResult(limitResult.Error!);
+                }
+            }
+
+            return new CallResult(null);
+        }
+
+        /// <summary>
+        /// Creates a request object
+        /// </summary>
+        /// <param name="baseAddress">Host and schema</param>
+        /// <param name="definition">Request definition</param>
+        /// <param name="uriParameters">The query parameters of the request</param>
+        /// <param name="bodyParameters">The body parameters of the request</param>
+        /// <param name="additionalHeaders">Additional headers to send with the request</param>
+        /// <returns></returns>
+        protected virtual IRequest CreateRequest(
+            string baseAddress,
+            RequestDefinition definition,
+            ParameterCollection? uriParameters,
+            ParameterCollection? bodyParameters,
+            Dictionary<string, string>? additionalHeaders)
+        {
+            var uriParams = uriParameters == null ? new ParameterCollection() : CreateParameterDictionary(uriParameters);
+            var bodyParams = bodyParameters == null ? new ParameterCollection() : CreateParameterDictionary(bodyParameters);
+
+            var uri = new Uri(baseAddress.AppendPath(definition.Path));
+            var arraySerialization = definition.ArraySerialization ?? ArraySerialization;
+            var bodyFormat = definition.RequestBodyFormat ?? RequestBodyFormat;
+            var requestId = ExchangeHelpers.NextId();
+            var parameterPosition = definition.ParameterPosition ?? ParameterPositions[definition.Method];
+
+            var headers = new Dictionary<string, string>();
+            if (AuthenticationProvider != null)
+            {
+                try
+                {
+                    AuthenticationProvider.AuthenticateRequest(
+                        this,
+                        uri,
+                        definition.Method,
+                        uriParams,
+                        bodyParams,
+                        headers,
+                        definition.Authenticated,
+                        arraySerialization,
+                        parameterPosition,
+                        bodyFormat                        
+                        );
+                }
+                catch (Exception ex)
+                {
+                    throw new Exception("Failed to authenticate request, make sure your API credentials are correct", ex);
+                }
+            }
+
+            // Add the auth parameters to the uri, start with a new URI to be able to sort the parameters including the auth parameters            
+            uri = uri.SetParameters(uriParams, arraySerialization);
+
+            var request = RequestFactory.Create(definition.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 = bodyFormat == RequestBodyFormat.Json ? Constants.JsonContentHeader : Constants.FormContentHeader;
+                if (bodyParams.Count != 0)
+                    WriteParamBody(request, bodyParams, contentType);
+                else
+                    request.SetContent(RequestBodyEmptyContent, contentType);
+            }
+
+            return request;
+        }
+
         /// <summary>
         /// Execute a request to the uri and returns if it was successful
         /// </summary>
@@ -127,7 +393,7 @@ namespace CryptoExchange.Net.Clients
         /// <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="additionalHeaders">Additional headers to send with the request</param>
-        /// <param name="ignoreRatelimit">Ignore rate limits for this request</param>
+        /// <param name="gate">The ratelimit gate to use</param>
         /// <returns></returns>
         [return: NotNull]
         protected virtual async Task<WebCallResult> SendRequestAsync(
@@ -141,23 +407,23 @@ namespace CryptoExchange.Net.Clients
             ArrayParametersSerialization? arraySerialization = null,
             int requestWeight = 1,
             Dictionary<string, string>? additionalHeaders = null,
-            bool ignoreRatelimit = false)
+            IRateLimitGate? gate = null)
         {
             int currentTry = 0;
             while (true)
             {
                 currentTry++;
-                var request = await PrepareRequestAsync(uri, method, cancellationToken, parameters, signed, requestBodyFormat, parameterPosition, arraySerialization, requestWeight, additionalHeaders, ignoreRatelimit).ConfigureAwait(false);
+                var request = await PrepareRequestAsync(uri, method, cancellationToken, parameters, signed, requestBodyFormat, parameterPosition, arraySerialization, requestWeight, additionalHeaders, gate).ConfigureAwait(false);
                 if (!request)
                     return new WebCallResult(request.Error!);
 
-                var result = await GetResponseAsync<object>(request.Data, cancellationToken).ConfigureAwait(false);
+                var result = await GetResponseAsync<object>(request.Data, gate, cancellationToken).ConfigureAwait(false);
                 if (!result)
                     _logger.RestApiErrorReceived(result.RequestId, result.ResponseStatusCode, (long)Math.Floor(result.ResponseTime!.Value.TotalMilliseconds), result.Error?.ToString());
                 else
                     _logger.RestApiResponseReceived(result.RequestId, result.ResponseStatusCode, (long)Math.Floor(result.ResponseTime!.Value.TotalMilliseconds), OutputOriginalData ? result.OriginalData : "[Data only available when OutputOriginal = true]");
 
-                if (await ShouldRetryRequestAsync(result, currentTry).ConfigureAwait(false))
+                if (await ShouldRetryRequestAsync(gate, result, currentTry).ConfigureAwait(false))
                     continue;
 
                 return result.AsDataless();
@@ -178,7 +444,7 @@ namespace CryptoExchange.Net.Clients
         /// <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="additionalHeaders">Additional headers to send with the request</param>
-        /// <param name="ignoreRatelimit">Ignore rate limits for this request</param>
+        /// <param name="gate">The ratelimit gate to use</param>
         /// <returns></returns>
         [return: NotNull]
         protected virtual async Task<WebCallResult<T>> SendRequestAsync<T>(
@@ -192,24 +458,24 @@ namespace CryptoExchange.Net.Clients
             ArrayParametersSerialization? arraySerialization = null,
             int requestWeight = 1,
             Dictionary<string, string>? additionalHeaders = null,
-            bool ignoreRatelimit = false
+            IRateLimitGate? gate = null
             ) where T : class
         {
             int currentTry = 0;
             while (true)
             {
                 currentTry++;
-                var request = await PrepareRequestAsync(uri, method, cancellationToken, parameters, signed, requestBodyFormat, parameterPosition, arraySerialization, requestWeight, additionalHeaders, ignoreRatelimit).ConfigureAwait(false);
+                var request = await PrepareRequestAsync(uri, method, cancellationToken, parameters, signed, requestBodyFormat, parameterPosition, arraySerialization, requestWeight, additionalHeaders, gate).ConfigureAwait(false);
                 if (!request)
                     return new WebCallResult<T>(request.Error!);
 
-                var result = await GetResponseAsync<T>(request.Data, cancellationToken).ConfigureAwait(false);
+                var result = await GetResponseAsync<T>(request.Data, gate, cancellationToken).ConfigureAwait(false);
                 if (!result)
                     _logger.RestApiErrorReceived(result.RequestId, result.ResponseStatusCode, (long)Math.Floor(result.ResponseTime!.Value.TotalMilliseconds), result.Error?.ToString());
                 else
                     _logger.RestApiResponseReceived(result.RequestId, result.ResponseStatusCode, (long)Math.Floor(result.ResponseTime!.Value.TotalMilliseconds), OutputOriginalData ? result.OriginalData : "[Data only available when OutputOriginal = true]");
 
-                if (await ShouldRetryRequestAsync(result, currentTry).ConfigureAwait(false))
+                if (await ShouldRetryRequestAsync(gate, result, currentTry).ConfigureAwait(false))
                     continue;
 
                 return result;
@@ -229,7 +495,7 @@ namespace CryptoExchange.Net.Clients
         /// <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="additionalHeaders">Additional headers to send with the request</param>
-        /// <param name="ignoreRatelimit">Ignore rate limits for this request</param>
+        /// <param name="gate">The rate limit gate to use</param>
         /// <returns></returns>
         protected virtual async Task<CallResult<IRequest>> PrepareRequestAsync(
             Uri uri,
@@ -242,12 +508,18 @@ namespace CryptoExchange.Net.Clients
             ArrayParametersSerialization? arraySerialization = null,
             int requestWeight = 1,
             Dictionary<string, string>? additionalHeaders = null,
-            bool ignoreRatelimit = false)
+            IRateLimitGate? gate = null)
         {
             var requestId = ExchangeHelpers.NextId();
 
             if (signed)
             {
+                if (AuthenticationProvider == null)
+                {
+                    _logger.RestApiNoApiCredentials(requestId, uri.AbsolutePath);
+                    return new CallResult<IRequest>(new NoApiCredentialsError());
+                }
+
                 var syncTask = SyncTimeAsync();
                 var timeSyncInfo = GetTimeSyncInfo();
 
@@ -262,23 +534,20 @@ namespace CryptoExchange.Net.Clients
                     }
                 }
             }
-
+            
-            if (!ignoreRatelimit)
+            if (requestWeight != 0)
             {
-                foreach (var limiter in RateLimiters)
+                if (gate == null)
+                    throw new Exception("Ratelimit gate not set when request weight is not 0");
+
+                if (ClientOptions.RateLimiterEnabled)
                 {
-                    var limitResult = await limiter.LimitRequestAsync(_logger, uri.AbsolutePath, method, signed, ApiOptions.ApiCredentials?.Key ?? ClientOptions.ApiCredentials?.Key, ApiOptions.RateLimitingBehaviour, requestWeight, cancellationToken).ConfigureAwait(false);
+                    var limitResult = await gate.ProcessAsync(_logger, requestId, RateLimitItemType.Request, new RequestDefinition(uri.AbsolutePath.TrimStart('/'), method) { Authenticated = signed }, uri.Host, AuthenticationProvider?._credentials.Key, requestWeight, ClientOptions.RateLimitingBehaviour, cancellationToken).ConfigureAwait(false);
-                    if (!limitResult.Success)
+                    if (!limitResult)
                         return new CallResult<IRequest>(limitResult.Error!);
                 }
             }
 
-            if (signed && AuthenticationProvider == null)
-            {
-                _logger.RestApiNoApiCredentials(requestId, uri.AbsolutePath);
-                return new CallResult<IRequest>(new NoApiCredentialsError());
-            }
-
             _logger.RestApiCreatingRequest(requestId, 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 ?? ArraySerialization, requestBodyFormat ?? RequestBodyFormat, requestId, additionalHeaders);
@@ -300,10 +569,12 @@ namespace CryptoExchange.Net.Clients
         /// 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="gate">The ratelimit gate used</param>
         /// <param name="cancellationToken">Cancellation token</param>
         /// <returns></returns>
         protected virtual async Task<WebCallResult<T>> GetResponseAsync<T>(
             IRequest request,
+            IRateLimitGate? gate,
             CancellationToken cancellationToken)
         {
             var sw = Stopwatch.StartNew();
@@ -328,9 +599,20 @@ namespace CryptoExchange.Net.Clients
 
                     Error error;
                     if (response.StatusCode == (HttpStatusCode)418 || response.StatusCode == (HttpStatusCode)429)
-                        error = ParseRateLimitResponse((int)response.StatusCode, response.ResponseHeaders, accessor);
+                    {
+                        var rateError = ParseRateLimitResponse((int)response.StatusCode, response.ResponseHeaders, accessor);
+                        if (rateError.RetryAfter != null && gate != null && ClientOptions.RateLimiterEnabled)
+                        {
+                            _logger.RestApiRateLimitPauseUntil(request.RequestId, rateError.RetryAfter.Value);
+                            await gate.SetRetryAfterGuardAsync(rateError.RetryAfter.Value).ConfigureAwait(false);
+                        }
+
+                        error = rateError;
+                    }
                     else
+                    {
                         error = ParseErrorResponse((int)response.StatusCode, response.ResponseHeaders, accessor);
+                    }
 
                     if (error.Code == null || error.Code == 0)
                         error.Code = (int)response.StatusCode;
@@ -346,7 +628,7 @@ namespace CryptoExchange.Net.Clients
                 if (!valid)
                 {
                     // Invalid json
-                    var error = new ServerError(accessor.OriginalDataAvailable ? accessor.GetOriginalString() : "[Data only available when OutputOriginal = true in client options]");
+                    var error = new ServerError("Failed to parse response: " + valid.Error!.Message, accessor.OriginalDataAvailable ? accessor.GetOriginalString() : "[Data only available when OutputOriginal = true in client options]");
                     return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, error);
                 }
 
@@ -400,10 +682,34 @@ namespace CryptoExchange.Net.Clients
         /// Note that this is always called; even when the request might be successful
         /// </summary>
         /// <typeparam name="T">WebCallResult type parameter</typeparam>
+        /// <param name="gate">The rate limit gate the call used</param>
         /// <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);
+        protected virtual async Task<bool> ShouldRetryRequestAsync<T>(IRateLimitGate? gate, WebCallResult<T> callResult, int tries)
+        {
+            if (tries >= 2)
+                // Only retry once
+                return false;
+
+            if ((int?)callResult.ResponseStatusCode == 429 
+                && ClientOptions.RateLimiterEnabled
+                && ClientOptions.RateLimitingBehaviour != RateLimitingBehaviour.Fail
+                && gate != null)
+            {
+                var retryTime = await gate.GetRetryAfterTime().ConfigureAwait(false);
+                if (retryTime == null)
+                    return false;
+
+                if (retryTime.Value - DateTime.UtcNow < TimeSpan.FromSeconds(60))
+                {
+                    _logger.RestApiRateLimitRetry(callResult.RequestId!.Value, retryTime.Value);
+                    return true;
+                }
+            }
+
+            return false;
+        }
 
         /// <summary>
         /// Creates a request object
@@ -445,8 +751,8 @@ namespace CryptoExchange.Net.Clients
             }
 
             var headers = new Dictionary<string, string>();
-            var uriParameters = parameterPosition == HttpMethodParameterPosition.InUri ? new SortedDictionary<string, object>(parameters) : new SortedDictionary<string, object>();
+            var uriParameters = parameterPosition == HttpMethodParameterPosition.InUri ? CreateParameterDictionary(parameters) : new Dictionary<string, object>();
-            var bodyParameters = parameterPosition == HttpMethodParameterPosition.InBody ? new SortedDictionary<string, object>(parameters) : new SortedDictionary<string, object>();
+            var bodyParameters = parameterPosition == HttpMethodParameterPosition.InBody ? CreateParameterDictionary(parameters) : new Dictionary<string, object>();
             if (AuthenticationProvider != null)
             {
                 try
@@ -455,14 +761,14 @@ namespace CryptoExchange.Net.Clients
                         this,
                         uri,
                         method,
-                        parameters,
+                        uriParameters,
+                        bodyParameters,
+                        headers,
                         signed,
                         arraySerialization,
                         parameterPosition,
-                        bodyFormat,
+                        bodyFormat
-                        out uriParameters,
+                        );
-                        out bodyParameters,
-                        out headers);
                 }
                 catch (Exception ex)
                 {
@@ -523,12 +829,16 @@ namespace CryptoExchange.Net.Clients
         /// <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)
+        protected virtual void WriteParamBody(IRequest request, IDictionary<string, object> parameters, string contentType)
         {
             if (contentType == Constants.JsonContentHeader)
             {
                 // Write the parameters as json in the body
-                var stringData = CreateSerializer().Serialize(parameters);
+                string stringData;
+                if (parameters.Count == 1 && parameters.ContainsKey(Constants.BodyPlaceHolderKey))
+                    stringData = CreateSerializer().Serialize(parameters[Constants.BodyPlaceHolderKey]);
+                else
+                    stringData = CreateSerializer().Serialize(parameters);
                 request.SetContent(stringData, contentType);
             }
             else if (contentType == Constants.FormContentHeader)
@@ -559,7 +869,7 @@ namespace CryptoExchange.Net.Clients
         /// <param name="responseHeaders">The response headers</param>
         /// <param name="accessor">Data accessor</param>
         /// <returns></returns>
-        protected virtual Error ParseRateLimitResponse(int httpStatusCode, IEnumerable<KeyValuePair<string, IEnumerable<string>>> responseHeaders, IMessageAccessor accessor)
+        protected virtual ServerRateLimitError ParseRateLimitResponse(int httpStatusCode, IEnumerable<KeyValuePair<string, IEnumerable<string>>> responseHeaders, IMessageAccessor accessor)
         {
             var message = accessor.OriginalDataAvailable ? accessor.GetOriginalString() : "[Error response content only available when OutputOriginal = true in client options]";
 
@@ -578,6 +888,19 @@ namespace CryptoExchange.Net.Clients
             return new ServerRateLimitError(message);
         }
 
+        /// <summary>
+        /// Create the parameter IDictionary
+        /// </summary>
+        /// <param name="parameters"></param>
+        /// <returns></returns>
+        protected internal IDictionary<string, object> CreateParameterDictionary(IDictionary<string, object> parameters)
+        {
+            if (!OrderParameters)
+                return parameters;
+
+            return new SortedDictionary<string, object>(parameters, ParameterOrderComparer);
+        }
+
         /// <summary>
         /// Retrieve the server time for the purpose of syncing time between client and server to prevent authentication issues
         /// </summary>

CryptoExchange.Net/Clients/SocketApiClient.cs

@@ -4,6 +4,7 @@ using CryptoExchange.Net.Logging.Extensions;
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.RateLimiting.Interfaces;
 using CryptoExchange.Net.Sockets;
 using Microsoft.Extensions.Logging;
 using System;
@@ -59,7 +60,7 @@ namespace CryptoExchange.Net.Clients
         /// <summary>
         /// The rate limiters 
         /// </summary>
-        protected internal IEnumerable<IRateLimiter>? RateLimiters { get; set; }
+        protected internal IRateLimitGate? RateLimiter { get; set; }
 
         /// <summary>
         /// The max size a websocket message size can be
@@ -67,7 +68,7 @@ namespace CryptoExchange.Net.Clients
         protected internal int? MessageSendSizeLimit { get; set; }
 
         /// <summary>
-        /// Periodic task regisrations
+        /// Periodic task registrations
         /// </summary>
         protected List<PeriodicTaskRegistration> PeriodicTaskRegistrations { get; set; } = new List<PeriodicTaskRegistration>();
 
@@ -121,10 +122,6 @@ namespace CryptoExchange.Net.Clients
                   options,
                   apiOptions)
         {
-            var rateLimiters = new List<IRateLimiter>();
-            foreach (var rateLimiter in apiOptions.RateLimiters)
-                rateLimiters.Add(rateLimiter);
-            RateLimiters = rateLimiters;
         }
 
         /// <summary>
@@ -281,10 +278,11 @@ namespace CryptoExchange.Net.Clients
         /// <summary>
         /// Send a query on a socket connection to the BaseAddress and wait for the response
         /// </summary>
-        /// <typeparam name="T">Expected result type</typeparam>
+        /// <typeparam name="THandlerResponse">Expected result type</typeparam>
+        /// <typeparam name="TServerResponse">The type returned to the caller</typeparam>
         /// <param name="query">The query</param>
         /// <returns></returns>
-        protected virtual Task<CallResult<T>> QueryAsync<T>(Query<T> query)
+        protected virtual Task<CallResult<THandlerResponse>> QueryAsync<TServerResponse, THandlerResponse>(Query<TServerResponse, THandlerResponse> query)
         {
             return QueryAsync(BaseAddress, query);
         }
@@ -292,14 +290,15 @@ namespace CryptoExchange.Net.Clients
         /// <summary>
         /// Send a query on a socket connection and wait for the response
         /// </summary>
-        /// <typeparam name="T">The expected result type</typeparam>
+        /// <typeparam name="THandlerResponse">Expected result type</typeparam>
+        /// <typeparam name="TServerResponse">The type returned to the caller</typeparam>
         /// <param name="url">The url for the request</param>
         /// <param name="query">The query</param>
         /// <returns></returns>
-        protected virtual async Task<CallResult<T>> QueryAsync<T>(string url, Query<T> query)
+        protected virtual async Task<CallResult<THandlerResponse>> QueryAsync<TServerResponse, THandlerResponse>(string url, Query<TServerResponse, THandlerResponse> query)
         {
             if (_disposing)
-                return new CallResult<T>(new InvalidOperationError("Client disposed, can't query"));
+                return new CallResult<THandlerResponse>(new InvalidOperationError("Client disposed, can't query"));
 
             SocketConnection socketConnection;
             var released = false;
@@ -308,7 +307,7 @@ namespace CryptoExchange.Net.Clients
             {
                 var socketResult = await GetSocketConnection(url, query.Authenticated).ConfigureAwait(false);
                 if (!socketResult)
-                    return socketResult.As<T>(default);
+                    return socketResult.As<THandlerResponse>(default);
 
                 socketConnection = socketResult.Data;
 
@@ -321,7 +320,7 @@ namespace CryptoExchange.Net.Clients
 
                 var connectResult = await ConnectIfNeededAsync(socketConnection, query.Authenticated).ConfigureAwait(false);
                 if (!connectResult)
-                    return new CallResult<T>(connectResult.Error!);
+                    return new CallResult<THandlerResponse>(connectResult.Error!);
             }
             finally
             {
@@ -332,10 +331,10 @@ namespace CryptoExchange.Net.Clients
             if (socketConnection.PausedActivity)
             {
                 _logger.HasBeenPausedCantSendQueryAtThisMoment(socketConnection.SocketId);
-                return new CallResult<T>(new ServerError("Socket is paused"));
+                return new CallResult<THandlerResponse>(new ServerError("Socket is paused"));
             }
 
-            return await socketConnection.SendAndWaitQueryAsync(query).ConfigureAwait(false);
+            return await socketConnection.SendAndWaitQueryAsync<TServerResponse, THandlerResponse>(query).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -344,20 +343,20 @@ namespace CryptoExchange.Net.Clients
         /// <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)
+        protected virtual async Task<CallResult> ConnectIfNeededAsync(SocketConnection socket, bool authenticated)
         {
             if (socket.Connected)
-                return new CallResult<bool>(true);
+                return new CallResult(null);
 
             var connectResult = await ConnectSocketAsync(socket).ConfigureAwait(false);
             if (!connectResult)
-                return new CallResult<bool>(connectResult.Error!);
+                return connectResult;
 
             if (ClientOptions.DelayAfterConnect != TimeSpan.Zero)
                 await Task.Delay(ClientOptions.DelayAfterConnect).ConfigureAwait(false);
 
             if (!authenticated || socket.Authenticated)
-                return new CallResult<bool>(true);
+                return new CallResult(null);
 
             return await AuthenticateSocketAsync(socket).ConfigureAwait(false);
         }
@@ -367,10 +366,10 @@ namespace CryptoExchange.Net.Clients
         /// </summary>
         /// <param name="socket">Socket to authenticate</param>
         /// <returns></returns>
-        public virtual async Task<CallResult<bool>> AuthenticateSocketAsync(SocketConnection socket)
+        public virtual async Task<CallResult> AuthenticateSocketAsync(SocketConnection socket)
         {
             if (AuthenticationProvider == null)
-                return new CallResult<bool>(new NoApiCredentialsError());
+                return new CallResult(new NoApiCredentialsError());
 
             _logger.AttemptingToAuthenticate(socket.SocketId);
             var authRequest = GetAuthenticationRequest();
@@ -385,13 +384,13 @@ namespace CryptoExchange.Net.Clients
                         await socket.CloseAsync().ConfigureAwait(false);
 
                     result.Error!.Message = "Authentication failed: " + result.Error.Message;
-                    return new CallResult<bool>(result.Error)!;
+                    return new CallResult(result.Error)!;
                 }
             }
 
             _logger.Authenticated(socket.SocketId);
             socket.Authenticated = true;
-            return new CallResult<bool>(true);
+            return new CallResult(null);
         }
 
         /// <summary>
@@ -499,16 +498,17 @@ namespace CryptoExchange.Net.Clients
         /// </summary>
         /// <param name="socketConnection">The socket to connect</param>
         /// <returns></returns>
-        protected virtual async Task<CallResult<bool>> ConnectSocketAsync(SocketConnection socketConnection)
+        protected virtual async Task<CallResult> ConnectSocketAsync(SocketConnection socketConnection)
         {
-            if (await socketConnection.ConnectAsync().ConfigureAwait(false))
+            var connectResult = await socketConnection.ConnectAsync().ConfigureAwait(false);
+            if (connectResult)
             {
                 socketConnections.TryAdd(socketConnection.SocketId, socketConnection);
-                return new CallResult<bool>(true);
+                return connectResult;
             }
 
             socketConnection.Dispose();
-            return new CallResult<bool>(new CantConnectError());
+            return connectResult;
         }
 
         /// <summary>
@@ -521,7 +521,8 @@ namespace CryptoExchange.Net.Clients
             {
                 KeepAliveInterval = KeepAliveInterval,
                 ReconnectInterval = ClientOptions.ReconnectInterval,
-                RateLimiters = RateLimiters,
+                RateLimiter = ClientOptions.RateLimiterEnabled ? RateLimiter : null,
+                RateLimitingBehaviour = ClientOptions.RateLimitingBehaviour,
                 Proxy = ClientOptions.Proxy,
                 Timeout = ApiOptions.SocketNoDataTimeout ?? ClientOptions.SocketNoDataTimeout
             };
@@ -622,32 +623,76 @@ namespace CryptoExchange.Net.Clients
         /// </summary>
         public string GetSubscriptionsState(bool includeSubDetails = true)
         {
-            var sb = new StringBuilder();
+            return GetState(includeSubDetails).ToString();
-            sb.AppendLine($"{GetType().Name}");
+        }
-            sb.AppendLine($"  Connections: {socketConnections.Count}");
+
-            sb.AppendLine($"  Subscriptions: {CurrentSubscriptions}");
+        /// <summary>
-            sb.AppendLine($"  Download speed: {IncomingKbps} kbps");
+        /// Gets the state of the client
-            foreach (var connection in socketConnections)
+        /// </summary>
+        /// <param name="includeSubDetails">True to get details for each subscription</param>
+        /// <returns></returns>
+        public SocketApiClientState GetState(bool includeSubDetails = true)
+        {
+            var connectionStates = new List<SocketConnection.SocketConnectionState>();
+            foreach (var socketIdAndConnection in socketConnections)
             {
-                sb.AppendLine($"    Id: {connection.Key}");
+                SocketConnection connection = socketIdAndConnection.Value;
-                sb.AppendLine($"    Address: {connection.Value.ConnectionUri}");
+                SocketConnection.SocketConnectionState connectionState = connection.GetState(includeSubDetails);
-                sb.AppendLine($"    Subscriptions: {connection.Value.UserSubscriptionCount}");
+                connectionStates.Add(connectionState);
-                sb.AppendLine($"    Status: {connection.Value.Status}");
+            }
-                sb.AppendLine($"    Authenticated: {connection.Value.Authenticated}");
+
-                sb.AppendLine($"    Download speed: {connection.Value.IncomingKbps} kbps");
+            return new SocketApiClientState(socketConnections.Count, CurrentSubscriptions, IncomingKbps, connectionStates);
-                sb.AppendLine($"    Subscriptions:");
+        }
-                if (includeSubDetails)
+
-                {
+        /// <summary>
-                    foreach (var subscription in connection.Value.Subscriptions)
+        /// Get the current state of the client
-                    {
+        /// </summary>
-                        sb.AppendLine($"      Id: {subscription.Id}");
+        /// <param name="Connections">Number of sockets for this client</param>
-                        sb.AppendLine($"      Confirmed: {subscription.Confirmed}");
+        /// <param name="Subscriptions">Total number of subscriptions</param>
-                        sb.AppendLine($"      Invocations: {subscription.TotalInvocations}");
+        /// <param name="DownloadSpeed">Total download speed</param>
-                        sb.AppendLine($"      Identifiers: [{string.Join(", ", subscription.ListenerIdentifiers)}]");
+        /// <param name="ConnectionStates">State of each socket connection</param>
-                    }
+        public record SocketApiClientState(
-                }
+            int Connections,
+            int Subscriptions,
+            double DownloadSpeed,
+            List<SocketConnection.SocketConnectionState> ConnectionStates)
+        {
+            /// <summary>
+            /// Print the state of the client
+            /// </summary>
+            /// <param name="sb"></param>
+            /// <returns></returns>
+            protected virtual bool PrintMembers(StringBuilder sb)
+            {
+                sb.AppendLine();
+                sb.AppendLine($"\tTotal connections: {Connections}");
+                sb.AppendLine($"\tTotal subscriptions: {Subscriptions}");
+                sb.AppendLine($"\tDownload speed: {DownloadSpeed} kbps");
+                sb.AppendLine($"\tConnections:");
+                ConnectionStates.ForEach(cs =>
+                {
+                    sb.AppendLine($"\t\tId: {cs.Id}");
+                    sb.AppendLine($"\t\tAddress: {cs.Address}");
+                    sb.AppendLine($"\t\tTotal subscriptions: {cs.Subscriptions}");
+                    sb.AppendLine($"\t\tStatus: {cs.Status}");
+                    sb.AppendLine($"\t\tAuthenticated: {cs.Authenticated}");
+                    sb.AppendLine($"\t\tDownload speed: {cs.DownloadSpeed} kbps");
+                    sb.AppendLine($"\t\tPending queries: {cs.PendingQueries}");
+                    if (cs.SubscriptionStates?.Count > 0)
+                    {
+                        sb.AppendLine($"\t\tSubscriptions:");
+                        cs.SubscriptionStates.ForEach(subState =>
+                        {
+                            sb.AppendLine($"\t\t\tId: {subState.Id}");
+                            sb.AppendLine($"\t\t\tConfirmed: {subState.Confirmed}");
+                            sb.AppendLine($"\t\t\tInvocations: {subState.Invocations}");
+                            sb.AppendLine($"\t\t\tIdentifiers: [{string.Join(",", subState.Identifiers)}]");
+                        });
+                    }
+                });
+
+                return true;
             }
-            return sb.ToString();
         }
 
         /// <summary>

CryptoExchange.Net/Converters/ArrayPropertyAttribute.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace CryptoExchange.Net.Converters
 {

CryptoExchange.Net/Converters/JsonNet/DateTimeConverter.cs

@@ -1,4 +1,5 @@
-using Newtonsoft.Json;
+using Microsoft.Extensions.Primitives;
+using Newtonsoft.Json;
 using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
@@ -38,14 +39,8 @@ namespace CryptoExchange.Net.Converters.JsonNet
                 var longValue = (long)reader.Value;
                 if (longValue == 0 || longValue == -1)
                     return objectType == typeof(DateTime) ? default(DateTime): null;
-                if (longValue < 19999999999)
+
-                    return ConvertFromSeconds(longValue);
+                return ParseFromLong(longValue);
-                if (longValue < 19999999999999)
-                    return ConvertFromMilliseconds(longValue);
-                if (longValue < 19999999999999999)
-                    return ConvertFromMicroseconds(longValue);
-                
-                return ConvertFromNanoseconds(longValue);
             }
             else if (reader.TokenType is JsonToken.Float)
             {
@@ -68,61 +63,7 @@ namespace CryptoExchange.Net.Converters.JsonNet
                     return objectType == typeof(DateTime) ? default(DateTime) : null;
                 }
 
-                if (stringValue.Length == 8)
+                return ParseFromString(stringValue);
-                {
-                    // Parse 20211103 format
-                    if (!int.TryParse(stringValue.Substring(0, 4), out var year)
-                        || !int.TryParse(stringValue.Substring(4, 2), out var month)
-                        || !int.TryParse(stringValue.Substring(6, 2), out var day))
-                    {
-                        Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + reader.Value);
-                        return default;
-                    }
-                    return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
-                }
-
-                if (stringValue.Length == 6)
-                {
-                    // Parse 211103 format
-                    if (!int.TryParse(stringValue.Substring(0, 2), out var year)
-                        || !int.TryParse(stringValue.Substring(2, 2), out var month)
-                        || !int.TryParse(stringValue.Substring(4, 2), out var day))
-                    {
-                        Trace.WriteLine("{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + reader.Value);
-                        return default;
-                    }
-                    return new DateTime(year + 2000, month, day, 0, 0, 0, DateTimeKind.Utc);
-                }
-
-                if (double.TryParse(stringValue, NumberStyles.Float, CultureInfo.InvariantCulture, out var doubleValue))
-                {
-                    // Parse 1637745563.000 format
-                    if (doubleValue < 19999999999)
-                        return ConvertFromSeconds(doubleValue);
-                    if (doubleValue < 19999999999999)
-                        return ConvertFromMilliseconds((long)doubleValue);
-                    if (doubleValue < 19999999999999999)
-                        return ConvertFromMicroseconds((long)doubleValue);
-
-                    return ConvertFromNanoseconds((long)doubleValue);
-                }
-
-                if(stringValue.Length == 10)
-                {
-                    // Parse 2021-11-03 format
-                    var values = stringValue.Split('-');
-                    if(!int.TryParse(values[0], out var year)
-                        || !int.TryParse(values[1], out var month)
-                        || !int.TryParse(values[2], out var day))
-                    {
-                        Trace.WriteLine("{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + reader.Value);
-                        return default;
-                    }
-
-                    return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
-                }
-
-                return DateTime.Parse(stringValue, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
             }
             else if(reader.TokenType == JsonToken.Date)
             {
@@ -135,6 +76,102 @@ namespace CryptoExchange.Net.Converters.JsonNet
             }
         }
 
+        /// <summary>
+        /// Parse a long value to datetime
+        /// </summary>
+        /// <param name="longValue"></param>
+        /// <returns></returns>
+        public static DateTime ParseFromLong(long longValue)
+        {
+            if (longValue < 19999999999)
+                return ConvertFromSeconds(longValue);
+            if (longValue < 19999999999999)
+                return ConvertFromMilliseconds(longValue);
+            if (longValue < 19999999999999999)
+                return ConvertFromMicroseconds(longValue);
+
+            return ConvertFromNanoseconds(longValue);
+        }
+
+        /// <summary>
+        /// Parse a string value to datetime
+        /// </summary>
+        /// <param name="stringValue"></param>
+        /// <returns></returns>
+        public static DateTime ParseFromString(string stringValue)
+        {
+            if (stringValue.Length == 12 && stringValue.StartsWith("202"))
+            {
+                // Parse 202303261200 format
+                if (!int.TryParse(stringValue.Substring(0, 4), out var year)
+                    || !int.TryParse(stringValue.Substring(4, 2), out var month)
+                    || !int.TryParse(stringValue.Substring(6, 2), out var day)
+                    || !int.TryParse(stringValue.Substring(8, 2), out var hour)
+                    || !int.TryParse(stringValue.Substring(10, 2), out var minute))
+                {
+                    Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    return default;
+                }
+                return new DateTime(year, month, day, hour, minute, 0, DateTimeKind.Utc);
+            }
+
+            if (stringValue.Length == 8)
+            {
+                // Parse 20211103 format
+                if (!int.TryParse(stringValue.Substring(0, 4), out var year)
+                    || !int.TryParse(stringValue.Substring(4, 2), out var month)
+                    || !int.TryParse(stringValue.Substring(6, 2), out var day))
+                {
+                    Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    return default;
+                }
+                return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
+            }
+
+            if (stringValue.Length == 6)
+            {
+                // Parse 211103 format
+                if (!int.TryParse(stringValue.Substring(0, 2), out var year)
+                    || !int.TryParse(stringValue.Substring(2, 2), out var month)
+                    || !int.TryParse(stringValue.Substring(4, 2), out var day))
+                {
+                    Trace.WriteLine("{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    return default;
+                }
+                return new DateTime(year + 2000, month, day, 0, 0, 0, DateTimeKind.Utc);
+            }
+
+            if (double.TryParse(stringValue, NumberStyles.Float, CultureInfo.InvariantCulture, out var doubleValue))
+            {
+                // Parse 1637745563.000 format
+                if (doubleValue < 19999999999)
+                    return ConvertFromSeconds(doubleValue);
+                if (doubleValue < 19999999999999)
+                    return ConvertFromMilliseconds((long)doubleValue);
+                if (doubleValue < 19999999999999999)
+                    return ConvertFromMicroseconds((long)doubleValue);
+
+                return ConvertFromNanoseconds((long)doubleValue);
+            }
+
+            if (stringValue.Length == 10)
+            {
+                // Parse 2021-11-03 format
+                var values = stringValue.Split('-');
+                if (!int.TryParse(values[0], out var year)
+                    || !int.TryParse(values[1], out var month)
+                    || !int.TryParse(values[2], out var day))
+                {
+                    Trace.WriteLine("{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    return default;
+                }
+
+                return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
+            }
+
+            return DateTime.Parse(stringValue, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
+        }
+
         /// <summary>
         /// Convert a seconds since epoch (01-01-1970) value to DateTime
         /// </summary>

CryptoExchange.Net/Converters/JsonNet/JsonNetMessageAccessor.cs

@@ -224,7 +224,7 @@ namespace CryptoExchange.Net.Converters.JsonNet
         public override bool OriginalDataAvailable => _stream?.CanSeek == true;
 
         /// <inheritdoc />
-        public async Task<bool> Read(Stream stream, bool bufferStream)
+        public async Task<CallResult> Read(Stream stream, bool bufferStream)
         {
             if (bufferStream && stream is not MemoryStream)
             {
@@ -252,14 +252,15 @@ namespace CryptoExchange.Net.Converters.JsonNet
             {
                 _token = await JToken.LoadAsync(jsonTextReader).ConfigureAwait(false);
                 IsJson = true;
+                return new CallResult(null);
             }
-            catch (Exception)
+            catch (Exception ex)
             {
                 // Not a json message
                 IsJson = false;
+                return new CallResult(new ServerError("JsonError: " + ex.Message));
             }
 
-            return IsJson;
         }
         /// <inheritdoc />
         public override string GetOriginalString()
@@ -290,7 +291,7 @@ namespace CryptoExchange.Net.Converters.JsonNet
         private ReadOnlyMemory<byte> _bytes;
 
         /// <inheritdoc />
-        public bool Read(ReadOnlyMemory<byte> data)
+        public CallResult Read(ReadOnlyMemory<byte> data)
         {
             _bytes = data;
 
@@ -305,14 +306,14 @@ namespace CryptoExchange.Net.Converters.JsonNet
             {
                 _token = JToken.Load(jsonTextReader);
                 IsJson = true;
+                return new CallResult(null);
             }
-            catch (Exception)
+            catch (Exception ex)
             {
                 // Not a json message
                 IsJson = false;
+                return new CallResult(new ServerError("JsonError: " + ex.Message));
             }
-
-            return IsJson;
         }
 
         /// <inheritdoc />

CryptoExchange.Net/Converters/SystemTextJson/BoolConverter.cs

@@ -28,7 +28,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         {
             public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
                 => (T)((object?)ReadBool(ref reader, typeToConvert, options) ?? default(T))!;
-
+            
             public bool? ReadBool(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
             {
                 if (reader.TokenType == JsonTokenType.True)
@@ -74,7 +74,10 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 
             public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
             {
-                writer.WriteNullValue();
+                if (value is bool boolVal)
+                    writer.WriteBooleanValue(boolVal);
+                else
+                    writer.WriteNullValue();
             }
         }
 

CryptoExchange.Net/Converters/SystemTextJson/DateTimeConverter.cs

@@ -1,4 +1,5 @@
-using System;
+using Microsoft.Extensions.Primitives;
+using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
@@ -49,14 +50,8 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                     var longValue = reader.GetDouble();
                     if (longValue == 0 || longValue == -1)
                         return default;
-                    if (longValue < 19999999999)
-                        return ConvertFromSeconds(longValue);
-                    if (longValue < 19999999999999)
-                        return ConvertFromMilliseconds(longValue);
-                    if (longValue < 19999999999999999)
-                        return ConvertFromMicroseconds(longValue);
 
-                    return ConvertFromNanoseconds(longValue);
+                    return ParseFromDouble(longValue);
                 }
                 else if (reader.TokenType is JsonTokenType.String)
                 {
@@ -68,61 +63,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                         return default;
                     }
 
-                    if (stringValue!.Length == 8)
+                    return ParseFromString(stringValue!);
-                    {
-                        // Parse 20211103 format
-                        if (!int.TryParse(stringValue.Substring(0, 4), out var year)
-                            || !int.TryParse(stringValue.Substring(4, 2), out var month)
-                            || !int.TryParse(stringValue.Substring(6, 2), out var day))
-                        {
-                            Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
-                            return default;
-                        }
-                        return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
-                    }
-
-                    if (stringValue.Length == 6)
-                    {
-                        // Parse 211103 format
-                        if (!int.TryParse(stringValue.Substring(0, 2), out var year)
-                            || !int.TryParse(stringValue.Substring(2, 2), out var month)
-                            || !int.TryParse(stringValue.Substring(4, 2), out var day))
-                        {
-                            Trace.WriteLine("{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
-                            return default;
-                        }
-                        return new DateTime(year + 2000, month, day, 0, 0, 0, DateTimeKind.Utc);
-                    }
-
-                    if (double.TryParse(stringValue, NumberStyles.Float, CultureInfo.InvariantCulture, out var doubleValue))
-                    {
-                        // Parse 1637745563.000 format
-                        if (doubleValue < 19999999999)
-                            return ConvertFromSeconds(doubleValue);
-                        if (doubleValue < 19999999999999)
-                            return ConvertFromMilliseconds((long)doubleValue);
-                        if (doubleValue < 19999999999999999)
-                            return ConvertFromMicroseconds((long)doubleValue);
-
-                        return ConvertFromNanoseconds((long)doubleValue);
-                    }
-
-                    if (stringValue.Length == 10)
-                    {
-                        // Parse 2021-11-03 format
-                        var values = stringValue.Split('-');
-                        if (!int.TryParse(values[0], out var year)
-                            || !int.TryParse(values[1], out var month)
-                            || !int.TryParse(values[2], out var day))
-                        {
-                            Trace.WriteLine("{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
-                            return default;
-                        }
-
-                        return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
-                    }
-
-                    return DateTime.Parse(stringValue, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
                 }
                 else
                 {
@@ -145,6 +86,104 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             }
         }
 
+        /// <summary>
+        /// Parse a long value to datetime
+        /// </summary>
+        /// <param name="longValue"></param>
+        /// <returns></returns>
+        public static DateTime ParseFromDouble(double longValue)
+        {
+            if (longValue < 19999999999)
+                return ConvertFromSeconds(longValue);
+            if (longValue < 19999999999999)
+                return ConvertFromMilliseconds(longValue);
+            if (longValue < 19999999999999999)
+                return ConvertFromMicroseconds(longValue);
+
+            return ConvertFromNanoseconds(longValue);
+        }
+
+        /// <summary>
+        /// Parse a string value to datetime
+        /// </summary>
+        /// <param name="stringValue"></param>
+        /// <returns></returns>
+        public static DateTime ParseFromString(string stringValue)
+        {
+            if (stringValue!.Length == 12 && stringValue.StartsWith("202"))
+            {
+                // Parse 202303261200 format
+                if (!int.TryParse(stringValue.Substring(0, 4), out var year)
+                    || !int.TryParse(stringValue.Substring(4, 2), out var month)
+                    || !int.TryParse(stringValue.Substring(6, 2), out var day)
+                    || !int.TryParse(stringValue.Substring(8, 2), out var hour)
+                    || !int.TryParse(stringValue.Substring(10, 2), out var minute))
+                {
+                    Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    return default;
+                }
+                return new DateTime(year, month, day, hour, minute, 0, DateTimeKind.Utc);
+            }
+
+            if (stringValue.Length == 8)
+            {
+                // Parse 20211103 format
+                if (!int.TryParse(stringValue.Substring(0, 4), out var year)
+                    || !int.TryParse(stringValue.Substring(4, 2), out var month)
+                    || !int.TryParse(stringValue.Substring(6, 2), out var day))
+                {
+                    Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    return default;
+                }
+                return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
+            }
+
+            if (stringValue.Length == 6)
+            {
+                // Parse 211103 format
+                if (!int.TryParse(stringValue.Substring(0, 2), out var year)
+                    || !int.TryParse(stringValue.Substring(2, 2), out var month)
+                    || !int.TryParse(stringValue.Substring(4, 2), out var day))
+                {
+                    Trace.WriteLine("{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    return default;
+                }
+                return new DateTime(year + 2000, month, day, 0, 0, 0, DateTimeKind.Utc);
+            }
+
+            if (double.TryParse(stringValue, NumberStyles.Float, CultureInfo.InvariantCulture, out var doubleValue))
+            {
+                // Parse 1637745563.000 format
+                if (doubleValue <= 0)
+                    return default;
+                if (doubleValue < 19999999999)
+                    return ConvertFromSeconds(doubleValue);
+                if (doubleValue < 19999999999999)
+                    return ConvertFromMilliseconds((long)doubleValue);
+                if (doubleValue < 19999999999999999)
+                    return ConvertFromMicroseconds((long)doubleValue);
+
+                return ConvertFromNanoseconds((long)doubleValue);
+            }
+
+            if (stringValue.Length == 10)
+            {
+                // Parse 2021-11-03 format
+                var values = stringValue.Split('-');
+                if (!int.TryParse(values[0], out var year)
+                    || !int.TryParse(values[1], out var month)
+                    || !int.TryParse(values[2], out var day))
+                {
+                    Trace.WriteLine("{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    return default;
+                }
+
+                return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
+            }
+
+            return DateTime.Parse(stringValue, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
+        }
+
         /// <summary>
         /// Convert a seconds since epoch (01-01-1970) value to DateTime
         /// </summary>

CryptoExchange.Net/Converters/SystemTextJson/SystemTextJsonMessageAccessor.cs

@@ -68,6 +68,11 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                 var info = $"Deserialize JsonException: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
                 return new CallResult<T>(new DeserializeError(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
             }
+            catch (Exception ex)
+            {
+                var info = $"Unknown exception: {ex.Message}";
+                return new CallResult<T>(new DeserializeError(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+            }
         }
 
         /// <inheritdoc />
@@ -118,17 +123,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             if (value.Value.ValueKind == JsonValueKind.Object || value.Value.ValueKind == JsonValueKind.Array)
                 return default;
 
-            var ttype = typeof(T);
+            return value.Value.Deserialize<T>();
-            if (ttype == typeof(string))
-                return (T?)(object?)value.Value.GetString();
-            if (ttype == typeof(short))
-                return (T)(object)value.Value.GetInt16();
-            if (ttype == typeof(int))
-                return (T)(object)value.Value.GetInt32();
-            if (ttype == typeof(long))
-                return (T)(object)value.Value.GetInt64();
-
-            return default;
         }
 
         /// <inheritdoc />
@@ -198,7 +193,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         public override bool OriginalDataAvailable => _stream?.CanSeek == true;
 
         /// <inheritdoc />
-        public async Task<bool> Read(Stream stream, bool bufferStream)
+        public async Task<CallResult> Read(Stream stream, bool bufferStream)
         {
             if (bufferStream && stream is not MemoryStream)
             {
@@ -221,15 +216,16 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             {
                 _document = await JsonDocument.ParseAsync(_stream ?? stream).ConfigureAwait(false);
                 IsJson = true;
+                return new CallResult(null);
             }
-            catch (Exception)
+            catch (Exception ex)
             {
                 // Not a json message
                 IsJson = false;
+                return new CallResult(new ServerError("JsonError: " + ex.Message));
             }
-
-            return IsJson;
         }
+
         /// <inheritdoc />
         public override string GetOriginalString()
         {
@@ -259,7 +255,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         private ReadOnlyMemory<byte> _bytes;
 
         /// <inheritdoc />
-        public bool Read(ReadOnlyMemory<byte> data)
+        public CallResult Read(ReadOnlyMemory<byte> data)
         {
             _bytes = data;
 
@@ -267,14 +263,14 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             {
                 _document = JsonDocument.Parse(data);
                 IsJson = true;
+                return new CallResult(null);
             }
-            catch (Exception)
+            catch (Exception ex)
             {
                 // Not a json message
                 IsJson = false;
+                return new CallResult(new ServerError("JsonError: " + ex.Message));
             }
-
-            return IsJson;
         }
 
         /// <inheritdoc />

CryptoExchange.Net/CryptoExchange.Net.csproj

@@ -6,9 +6,9 @@
     <PackageId>CryptoExchange.Net</PackageId>
     <Authors>JKorf</Authors>
     <Description>CryptoExchange.Net is a base library which is used to implement different cryptocurrency (exchange) API's. It provides a standardized way of implementing different API's, which results in a very similar experience for users of the API implementations.</Description>
-    <PackageVersion>7.2.0</PackageVersion>
+    <PackageVersion>7.5.2</PackageVersion>
-    <AssemblyVersion>7.2.0</AssemblyVersion>
+    <AssemblyVersion>7.5.2</AssemblyVersion>
-    <FileVersion>7.2.0</FileVersion>
+    <FileVersion>7.5.2</FileVersion>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>OKX;OKX.Net;Mexc;Mexc.Net;Kucoin;Kucoin.Net;Kraken;Kraken.Net;Huobi;Huobi.Net;CoinEx;CoinEx.Net;Bybit;Bybit.Net;Bitget;Bitget.Net;Bitfinex;Bitfinex.Net;Binance;Binance.Net;CryptoCurrency;CryptoCurrency Exchange</PackageTags>
     <RepositoryType>git</RepositoryType>

CryptoExchange.Net/ExtensionMethods.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO.Compression;
 using System.IO;
 using System.Linq;
@@ -9,12 +8,7 @@ using System.Security;
 using System.Text;
 using System.Web;
 using CryptoExchange.Net.Objects;
-using Microsoft.Extensions.Logging;
 using System.Globalization;
-using System.Collections;
-using System.Net.Http;
-using System.Data.Common;
-using Newtonsoft.Json.Linq;
 
 namespace CryptoExchange.Net
 {
@@ -348,7 +342,7 @@ namespace CryptoExchange.Net
         /// <param name="baseUri"></param>
         /// <param name="arraySerialization"></param>
         /// <returns></returns>
-        public static Uri SetParameters(this Uri baseUri, SortedDictionary<string, object> parameters, ArrayParametersSerialization arraySerialization)
+        public static Uri SetParameters(this Uri baseUri, IDictionary<string, object> parameters, ArrayParametersSerialization arraySerialization)
         {
             var uriBuilder = new UriBuilder();
             uriBuilder.Scheme = baseUri.Scheme;

CryptoExchange.Net/Interfaces/IAuthTimeProvider.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace CryptoExchange.Net.Interfaces
+{
+    /// <summary>
+    /// Time provider
+    /// </summary>
+    internal interface IAuthTimeProvider
+    {
+        /// <summary>
+        /// Get current time
+        /// </summary>
+        /// <returns></returns>
+        DateTime GetTime();
+    }
+}

CryptoExchange.Net/Interfaces/IBaseApiClient.cs

@@ -12,6 +12,14 @@ namespace CryptoExchange.Net.Interfaces
         /// </summary>
         string BaseAddress { get; }
 
+        /// <summary>
+        /// Format a base and quote asset to an exchange accepted symbol 
+        /// </summary>
+        /// <param name="baseAsset">The base asset</param>
+        /// <param name="quoteAsset">The quote asset</param>
+        /// <returns></returns>
+        string FormatSymbol(string baseAsset, string quoteAsset);
+
         /// <summary>
         /// Set the API credentials for this API client
         /// </summary>

CryptoExchange.Net/Interfaces/ICryptoRestClient.cs

@@ -1,8 +1,6 @@
 using CryptoExchange.Net.Interfaces.CommonClients;
-using Microsoft.Extensions.DependencyInjection;
 using System;
 using System.Collections.Generic;
-using System.Text;
 
 namespace CryptoExchange.Net.Interfaces
 {

CryptoExchange.Net/Interfaces/ICryptoSocketClient.cs

@@ -1,8 +1,4 @@
-using CryptoExchange.Net.Interfaces.CommonClients;
+using System;
-using Microsoft.Extensions.DependencyInjection;
-using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace CryptoExchange.Net.Interfaces
 {

CryptoExchange.Net/Interfaces/IMessageAccessor.cs

@@ -84,7 +84,7 @@ namespace CryptoExchange.Net.Interfaces
         /// </summary>
         /// <param name="stream"></param>
         /// <param name="bufferStream"></param>
-        Task<bool> Read(Stream stream, bool bufferStream);
+        Task<CallResult> Read(Stream stream, bool bufferStream);
     }
 
     /// <summary>
@@ -96,6 +96,6 @@ namespace CryptoExchange.Net.Interfaces
         /// Load a data message
         /// </summary>
         /// <param name="data"></param>
-        bool Read(ReadOnlyMemory<byte> data);
+        CallResult Read(ReadOnlyMemory<byte> data);
     }
 }

CryptoExchange.Net/Interfaces/IMessageProcessor.cs

@@ -3,7 +3,6 @@ using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.Sockets;
 using System;
 using System.Collections.Generic;
-using System.Threading.Tasks;
 
 namespace CryptoExchange.Net.Interfaces
 {

CryptoExchange.Net/Interfaces/IOrderBookFactory.cs

@@ -0,0 +1,27 @@
+using CryptoExchange.Net.Objects.Options;
+using System;
+
+namespace CryptoExchange.Net.Interfaces
+{
+    /// <summary>
+    /// Factory for ISymbolOrderBook instances
+    /// </summary>
+    public interface IOrderBookFactory<TOptions> where TOptions : OrderBookOptions
+    {
+        /// <summary>
+        /// Create a new order book by symbol name
+        /// </summary>
+        /// <param name="symbol">Symbol name</param>
+        /// <param name="options">Options for the order book</param>
+        /// <returns></returns>
+        public ISymbolOrderBook Create(string symbol, Action<TOptions>? options = null);
+        /// <summary>
+        /// Create a new order book by base and quote asset names
+        /// </summary>
+        /// <param name="baseAsset">Base asset name</param>
+        /// <param name="quoteAsset">Quote asset name</param>
+        /// <param name="options">Options for the order book</param>
+        /// <returns></returns>
+        public ISymbolOrderBook Create(string baseAsset, string quoteAsset, Action<TOptions>? options = null);
+    }
+}

CryptoExchange.Net/Interfaces/IWebsocket.cs

@@ -1,5 +1,5 @@
-using System;
+using CryptoExchange.Net.Objects;
-using System.IO;
+using System;
 using System.Net.WebSockets;
 using System.Threading.Tasks;
 
@@ -23,6 +23,10 @@ namespace CryptoExchange.Net.Interfaces
         /// </summary>
         event Func<int, Task> OnRequestSent;
         /// <summary>
+        /// Websocket query was ratelimited and couldn't be send
+        /// </summary>
+        event Func<int, Task>? OnRequestRateLimited;
+        /// <summary>
         /// Websocket error event
         /// </summary>
         event Func<Exception, Task> OnError;
@@ -67,7 +71,7 @@ namespace CryptoExchange.Net.Interfaces
         /// Connect the socket
         /// </summary>
         /// <returns></returns>
-        Task<bool> ConnectAsync();
+        Task<CallResult> ConnectAsync();
         /// <summary>
         /// Send data
         /// </summary>

CryptoExchange.Net/Logging/Extensions/CryptoExchangeWebSocketClientLoggingExtension.cs

@@ -20,7 +20,6 @@ namespace CryptoExchange.Net.Logging.Extensions
         private static readonly Action<ILogger, int, Exception?> _closed;
         private static readonly Action<ILogger, int, Exception?> _disposing;
         private static readonly Action<ILogger, int, Exception?> _disposed;
-        private static readonly Action<ILogger, int, int, int, Exception?> _sendDelayedBecauseOfRateLimit;
         private static readonly Action<ILogger, int, int, int, Exception?> _sentBytes;
         private static readonly Action<ILogger, int, string, Exception?> _sendLoopStoppedWithException;
         private static readonly Action<ILogger, int, Exception?> _sendLoopFinished;
@@ -74,7 +73,7 @@ namespace CryptoExchange.Net.Logging.Extensions
             _addingBytesToSendBuffer = LoggerMessage.Define<int, int, int>(
                 LogLevel.Trace,
                 new EventId(1007, "AddingBytesToSendBuffer"),
-                "[Sckt {SocketId}] msg {RequestId} - Adding {NumBytes} bytes to send buffer");
+                "[Sckt {SocketId}] [Req {RequestId}] adding {NumBytes} bytes to send buffer");
 
             _reconnectRequested = LoggerMessage.Define<int>(
                 LogLevel.Debug,
@@ -111,15 +110,10 @@ namespace CryptoExchange.Net.Logging.Extensions
                 new EventId(1014, "Disposed"),
                 "[Sckt {SocketId}] disposed");
 
-            _sendDelayedBecauseOfRateLimit = LoggerMessage.Define<int, int, int>(
-                LogLevel.Debug,
-                new EventId(1015, "SendDelayedBecauseOfRateLimit"),
-                "[Sckt {SocketId}] msg {RequestId} - send delayed {DelayMS}ms because of rate limit");
-
             _sentBytes = LoggerMessage.Define<int, int, int>(
                 LogLevel.Trace,
                 new EventId(1016, "SentBytes"),
-                "[Sckt {SocketId}] msg {RequestId} - sent {NumBytes} bytes");
+                "[Sckt {SocketId}] [Req {RequestId}] sent {NumBytes} bytes");
 
             _sendLoopStoppedWithException = LoggerMessage.Define<int, string>(
                 LogLevel.Warning,
@@ -267,12 +261,6 @@ namespace CryptoExchange.Net.Logging.Extensions
             _disposed(logger, socketId, null);
         }
 
-        public static void SocketSendDelayedBecauseOfRateLimit(
-            this ILogger logger, int socketId, int requestId, int delay)
-        {
-            _sendDelayedBecauseOfRateLimit(logger, socketId, requestId, delay, null);
-        }
-
         public static void SocketSentBytes(
             this ILogger logger, int socketId, int requestId, int numBytes)
         {

CryptoExchange.Net/Logging/Extensions/RateLimitGateLoggingExtensions.cs

@@ -0,0 +1,78 @@
+using Microsoft.Extensions.Logging;
+using System;
+
+namespace CryptoExchange.Net.Logging.Extensions
+{
+    internal static class RateLimitGateLoggingExtensions
+    {
+        private static readonly Action<ILogger, int, string, string, string, Exception?> _rateLimitRequestFailed;
+        private static readonly Action<ILogger, int, string, string, Exception?> _rateLimitConnectionFailed;
+        private static readonly Action<ILogger, int, string, TimeSpan, string, string, Exception?> _rateLimitDelayingRequest;
+        private static readonly Action<ILogger, int, TimeSpan, string, string, Exception?> _rateLimitDelayingConnection;
+        private static readonly Action<ILogger, int, string, string, string, int, Exception?> _rateLimitAppliedRequest;
+        private static readonly Action<ILogger, int, string, string, int, Exception?> _rateLimitAppliedConnection;
+
+        static RateLimitGateLoggingExtensions()
+        {
+            _rateLimitRequestFailed = LoggerMessage.Define<int, string, string, string>(
+                LogLevel.Warning,
+                new EventId(6000, "RateLimitRequestFailed"),
+                "[Req {Id}] Call to {Path} failed because of ratelimit guard {Guard}; {Limit}");
+
+            _rateLimitConnectionFailed = LoggerMessage.Define<int, string, string>(
+                LogLevel.Warning,
+                new EventId(6001, "RateLimitConnectionFailed"),
+                "[Sckt {Id}] Connection failed because of ratelimit guard {Guard}; {Limit}");
+
+            _rateLimitDelayingRequest = LoggerMessage.Define<int, string, TimeSpan, string, string>(
+                LogLevel.Warning,
+                new EventId(6002, "RateLimitDelayingRequest"),
+                "[Req {Id}] Delaying call to {Path} by {Delay} because of ratelimit guard {Guard}; {Limit}");
+
+            _rateLimitDelayingConnection = LoggerMessage.Define<int, TimeSpan, string, string>(
+                LogLevel.Warning,
+                new EventId(6003, "RateLimitDelayingConnection"),
+                "[Sckt {Id}] Delaying connection by {Delay} because of ratelimit guard {Guard}; {Limit}");
+
+            _rateLimitAppliedConnection = LoggerMessage.Define<int, string, string, int>(
+                LogLevel.Trace,
+                new EventId(6004, "RateLimitDelayingConnection"),
+                "[Sckt {Id}] Connection passed ratelimit guard {Guard}; {Limit}, New count: {Current}");
+
+            _rateLimitAppliedRequest = LoggerMessage.Define<int, string, string, string, int>(
+                LogLevel.Trace,
+                new EventId(6005, "RateLimitAppliedRequest"),
+                "[Req {Id}] Call to {Path} passed ratelimit guard {Guard}; {Limit}, New count: {Current}");
+        }
+
+        public static void RateLimitRequestFailed(this ILogger logger, int requestId, string path, string guard, string limit)
+        {
+            _rateLimitRequestFailed(logger, requestId, path, guard, limit, null);
+        }
+
+        public static void RateLimitConnectionFailed(this ILogger logger, int connectionId, string guard, string limit)
+        {
+            _rateLimitConnectionFailed(logger, connectionId, guard, limit, null);
+        }
+
+        public static void RateLimitDelayingRequest(this ILogger logger, int requestId, string path, TimeSpan delay, string guard, string limit)
+        {
+            _rateLimitDelayingRequest(logger, requestId, path, delay, guard, limit, null);
+        }
+
+        public static void RateLimitDelayingConnection(this ILogger logger, int connectionId, TimeSpan delay, string guard, string limit)
+        {
+            _rateLimitDelayingConnection(logger, connectionId, delay, guard, limit, null);
+        }
+
+        public static void RateLimitAppliedConnection(this ILogger logger, int connectionId, string guard, string limit, int current)
+        {
+            _rateLimitAppliedConnection(logger, connectionId, guard, limit, current, null);
+        }
+
+        public static void RateLimitAppliedRequest(this ILogger logger, int requestIdId, string path, string guard, string limit, int current)
+        {
+            _rateLimitAppliedRequest(logger, requestIdId, path, guard, limit, current, null);
+        }
+    }
+}

CryptoExchange.Net/Logging/Extensions/RestApiClientLoggingExtensions.cs

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.Logging;
+using CryptoExchange.Net.Objects;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Net;
 using System.Net.Http;
@@ -13,6 +14,9 @@ namespace CryptoExchange.Net.Logging.Extensions
         private static readonly Action<ILogger, int, string, Exception?> _restApiNoApiCredentials;
         private static readonly Action<ILogger, int, Uri, Exception?> _restApiCreatingRequest;
         private static readonly Action<ILogger, int, HttpMethod, string, Uri, string, Exception?> _restApiSendingRequest;
+        private static readonly Action<ILogger, int, DateTime, Exception?> _restApiRateLimitRetry;
+        private static readonly Action<ILogger, int, DateTime, Exception?> _restApiRateLimitPauseUntil;
+        private static readonly Action<ILogger, int, RequestDefinition, string?, string, string, Exception?> _restApiSendRequest;
 
 
         static RestApiClientLoggingExtensions()
@@ -46,6 +50,21 @@ namespace CryptoExchange.Net.Logging.Extensions
                 LogLevel.Trace,
                 new EventId(4005, "RestApiSendingRequest"),
                 "[Req {RequestId}] Sending {Method} {Signed} request to {RestApiUri}{Query}");
+
+            _restApiRateLimitRetry = LoggerMessage.Define<int, DateTime>(
+                LogLevel.Warning,
+                new EventId(4006, "RestApiRateLimitRetry"),
+                "[Req {RequestId}] Received ratelimit error, retrying after {Timestamp}");
+
+            _restApiRateLimitPauseUntil = LoggerMessage.Define<int, DateTime>(
+                LogLevel.Warning,
+                new EventId(4007, "RestApiRateLimitPauseUntil"),
+                "[Req {RequestId}] Ratelimit error from server, pausing requests until {Until}");
+
+            _restApiSendRequest = LoggerMessage.Define<int, RequestDefinition, string?, string, string>(
+                LogLevel.Debug,
+                new EventId(4008, "RestApiSendRequest"),
+                "[Req {RequestId}] Sending {Definition} request with body {Body}, query parameters {Query} and headers {Headers}");
         }
 
         public static void RestApiErrorReceived(this ILogger logger, int? requestId, HttpStatusCode? responseStatusCode, long responseTime, string? error)
@@ -77,5 +96,20 @@ namespace CryptoExchange.Net.Logging.Extensions
         {
             _restApiSendingRequest(logger, requestId, method, signed, uri, paramString, null);
         }
+
+        public static void RestApiRateLimitRetry(this ILogger logger, int requestId, DateTime retryAfter)
+        {
+            _restApiRateLimitRetry(logger, requestId, retryAfter, null);
+        }
+
+        public static void RestApiRateLimitPauseUntil(this ILogger logger, int requestId, DateTime retryAfter)
+        {
+            _restApiRateLimitPauseUntil(logger, requestId, retryAfter, null);
+        }
+
+        public static void RestApiSendRequest(this ILogger logger, int requestId, RequestDefinition definition, string? body, string query, string headers)
+        {
+            _restApiSendRequest(logger, requestId, definition, body, query, headers, null);
+        }
     }
 }

CryptoExchange.Net/Logging/Extensions/SocketConnectionLoggingExtension.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Net.WebSockets;
-using CryptoExchange.Net.Objects;
 using Microsoft.Extensions.Logging;
 
 namespace CryptoExchange.Net.Logging.Extensions
@@ -73,7 +72,7 @@ namespace CryptoExchange.Net.Logging.Extensions
             _messageSentNotPending = LoggerMessage.Define<int, int>(
                 LogLevel.Debug,
                 new EventId(2006, "MessageSentNotPending"),
-                "[Sckt {SocketId}] msg {RequestId} - message sent, but not pending");
+                "[Sckt {SocketId}] [Req {RequestId}] message sent, but not pending");
 
             _receivedData = LoggerMessage.Define<int, string>(
                 LogLevel.Trace,
@@ -178,12 +177,12 @@ namespace CryptoExchange.Net.Logging.Extensions
             _periodicSendFailed = LoggerMessage.Define<int, string, string>(
                 LogLevel.Warning,
                 new EventId(2027, "PeriodicSendFailed"),
-                "[Sckt {SocketId}] Periodic send {Identifier} failed: {ErrorMessage}");
+                "[Sckt {SocketId}] periodic send {Identifier} failed: {ErrorMessage}");
 
             _sendingData = LoggerMessage.Define<int, int, string>(
                 LogLevel.Trace,
                 new EventId(2028, "SendingData"),
-                "[Sckt {SocketId}] msg {RequestId} - sending messsage: {Data}");
+                "[Sckt {SocketId}] [Req {RequestId}] sending messsage: {Data}");
 
             _receivedMessageNotMatchedToAnyListener = LoggerMessage.Define<int, string, string>(
                 LogLevel.Warning,

CryptoExchange.Net/Objects/AuthTimeProvider.cs

@@ -0,0 +1,10 @@
+using CryptoExchange.Net.Interfaces;
+using System;
+
+namespace CryptoExchange.Net.Objects
+{
+    internal class AuthTimeProvider : IAuthTimeProvider
+    {
+        public DateTime GetTime() => DateTime.UtcNow;
+    }
+}

CryptoExchange.Net/Objects/Constants.cs

@@ -13,5 +13,9 @@
         /// Form content type header
         /// </summary>
         public const string FormContentHeader = "application/x-www-form-urlencoded";
+        /// <summary>
+        /// Placeholder key for when request body should be set to the value of this KVP
+        /// </summary>
+        public const string BodyPlaceHolderKey = "_BODY_";
     }
 }

CryptoExchange.Net/Objects/Enums.cs

@@ -15,6 +15,29 @@
         Wait
     }
 
+    /// <summary>
+    /// What to do when a request would exceed the rate limit
+    /// </summary>
+    public enum RateLimitWindowType
+    {
+        /// <summary>
+        /// A sliding window
+        /// </summary>
+        Sliding,
+        /// <summary>
+        /// A fixed interval window
+        /// </summary>
+        Fixed,
+        /// <summary>
+        /// A fixed interval starting after the first request
+        /// </summary>
+        FixedAfterFirst,
+        /// <summary>
+        /// Decaying window
+        /// </summary>
+        Decay
+    }
+
     /// <summary>
     /// Where the parameters for a HttpMethod should be added in a request
     /// </summary>

CryptoExchange.Net/Objects/Options/ExchangeOptions.cs

@@ -28,6 +28,15 @@ namespace CryptoExchange.Net.Objects.Options
         /// </summary>        
         public ApiCredentials? ApiCredentials { get; set; }
 
+        /// <summary>
+        /// Whether or not client side rate limiting should be applied
+        /// </summary>
+        public bool RateLimiterEnabled { get; set; } = true;
+        /// <summary>
+        /// What should happen when a rate limit is reached
+        /// </summary>
+        public RateLimitingBehaviour RateLimitingBehaviour { get; set; } = RateLimitingBehaviour.Wait;
+
         /// <inheritdoc />
         public override string ToString()
         {

CryptoExchange.Net/Objects/Options/OrderBookOptions.cs

@@ -3,7 +3,7 @@
     /// <summary>
     /// Base for order book options
     /// </summary>
-    public class OrderBookOptions : ExchangeOptions
+    public class OrderBookOptions
     {
         /// <summary>
         /// Whether or not checksum validation is enabled. Default is true, disabling will ignore checksum messages.
@@ -19,11 +19,7 @@
         {
             return new T
             {
-                ApiCredentials = ApiCredentials?.Copy(),
-                OutputOriginalData = OutputOriginalData,
                 ChecksumValidationEnabled = ChecksumValidationEnabled,
-                Proxy = Proxy,
-                RequestTimeout = RequestTimeout
             };
         }
     }

CryptoExchange.Net/Objects/Options/RestApiOptions.cs

@@ -1,7 +1,5 @@
 using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Interfaces;
 using System;
-using System.Collections.Generic;
 
 namespace CryptoExchange.Net.Objects.Options
 {
@@ -10,16 +8,6 @@ namespace CryptoExchange.Net.Objects.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>
@@ -42,8 +30,6 @@ namespace CryptoExchange.Net.Objects.Options
                 ApiCredentials = ApiCredentials?.Copy(),
                 OutputOriginalData = OutputOriginalData,
                 AutoTimestamp = AutoTimestamp,
-                RateLimiters = RateLimiters,
-                RateLimitingBehaviour = RateLimitingBehaviour,
                 TimestampRecalculationInterval = TimestampRecalculationInterval
             };
         }

CryptoExchange.Net/Objects/Options/RestExchangeOptions.cs

@@ -32,7 +32,9 @@ namespace CryptoExchange.Net.Objects.Options
                 TimestampRecalculationInterval = TimestampRecalculationInterval,
                 ApiCredentials = ApiCredentials?.Copy(),
                 Proxy = Proxy,
-                RequestTimeout = RequestTimeout
+                RequestTimeout = RequestTimeout,
+                RateLimiterEnabled = RateLimiterEnabled,
+                RateLimitingBehaviour = RateLimitingBehaviour
             };
         }
     }

CryptoExchange.Net/Objects/Options/SocketApiOptions.cs

@@ -1,7 +1,5 @@
 using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Interfaces;
 using System;
-using System.Collections.Generic;
 
 namespace CryptoExchange.Net.Objects.Options
 {
@@ -10,11 +8,6 @@ namespace CryptoExchange.Net.Objects.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
@@ -37,7 +30,6 @@ namespace CryptoExchange.Net.Objects.Options
             {
                 ApiCredentials = ApiCredentials?.Copy(),
                 OutputOriginalData = OutputOriginalData,
-                RateLimiters = RateLimiters,
                 SocketNoDataTimeout = SocketNoDataTimeout,
                 MaxSocketConnections = MaxSocketConnections,
             };

CryptoExchange.Net/Objects/Options/SocketExchangeOptions.cs

@@ -65,7 +65,9 @@ namespace CryptoExchange.Net.Objects.Options
                 SocketSubscriptionsCombineTarget = SocketSubscriptionsCombineTarget,
                 MaxSocketConnections = MaxSocketConnections,
                 Proxy = Proxy,
-                RequestTimeout = RequestTimeout
+                RequestTimeout = RequestTimeout,
+                RateLimitingBehaviour = RateLimitingBehaviour,
+                RateLimiterEnabled = RateLimiterEnabled,
             };
         }
     }

CryptoExchange.Net/Objects/OrderedStringComparer.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.Objects
+{
+    /// <summary>
+    /// Order string comparer, sorts by alphabetical order
+    /// </summary>
+    public class OrderedStringComparer : IComparer<string>
+    {
+        /// <summary>
+        /// Compare function
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <returns></returns>
+        public int Compare(string x, string y)
+        {
+            // Shortcuts: If both are null, they are the same.
+            if (x == null && y == null) return 0;
+
+            // If one is null and the other isn't, then the
+            // one that is null is "lesser".
+            if (x == null) return -1;
+            if (y == null) return 1;
+
+            return x.CompareTo(y);
+        }
+    }
+}

CryptoExchange.Net/Objects/ParameterCollection.cs

@@ -1,9 +1,9 @@
 using CryptoExchange.Net.Attributes;
-using CryptoExchange.Net.Converters;
 using CryptoExchange.Net.Converters.SystemTextJson;
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.Linq;
 
 namespace CryptoExchange.Net.Objects
 {
@@ -194,5 +194,18 @@ namespace CryptoExchange.Net.Objects
                 Add(key, int.Parse(stringVal));
             }
         }
+
+        /// <summary>
+        /// Set the request body. Can be used to specify a simple value or array as the body instead of an object
+        /// </summary>
+        /// <param name="body">Body to set</param>
+        /// <exception cref="InvalidOperationException"></exception>
+        public void SetBody(object body)
+        {
+            if (this.Any())
+                throw new InvalidOperationException("Can't set body when other parameters already specified");
+
+            Add(Constants.BodyPlaceHolderKey, body);
+        }
     }
 }

CryptoExchange.Net/Objects/RateLimiter.cs

@@ -1,443 +0,0 @@
-using CryptoExchange.Net.Interfaces;
-using Microsoft.Extensions.Logging;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Net.Http;
-using System.Security;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.Objects
-{
-    /// <summary>
-    /// Limits the amount of requests to a certain constraint
-    /// </summary>
-    public class RateLimiter : IRateLimiter
-    {
-        private readonly object _limiterLock = new object();
-        internal List<Limiter> _limiters = new List<Limiter>();
-
-        /// <summary>
-        /// Create a new RateLimiter. Configure the rate limiter by calling <see cref="AddTotalRateLimit"/>, 
-        /// <see cref="AddEndpointLimit(string, int, TimeSpan, HttpMethod?, bool)"/>, <see cref="AddPartialEndpointLimit(string, int, TimeSpan, HttpMethod?, bool, bool)"/> or <see cref="AddApiKeyLimit"/>.
-        /// </summary>
-        public RateLimiter()
-        {
-        }
-
-        /// <summary>
-        /// Add a rate limit for the total amount of requests per time period
-        /// </summary>
-        /// <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 AddTotalRateLimit(int limit, TimeSpan perTimePeriod)
-        {
-            lock(_limiterLock)
-                _limiters.Add(new TotalRateLimiter(limit, perTimePeriod, null));
-            return this;
-        }
-
-        /// <summary>
-        /// Add a rate lmit for the amount of requests per time for an endpoint
-        /// </summary>
-        /// <param name="endpoint">The endpoint 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>
-        /// <param name="method">The HttpMethod the limit is for, null for all</param>
-        /// <param name="excludeFromOtherRateLimits">If set to true it ignores other rate limits</param>
-        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));
-            return this;
-        }
-
-        /// <summary>
-        /// Add a rate lmit for the amount of requests per time for an endpoint
-        /// </summary>
-        /// <param name="endpoints">The endpoints 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>
-        /// <param name="method">The HttpMethod the limit is for, null for all</param>
-        /// <param name="excludeFromOtherRateLimits">If set to true it ignores other rate limits</param>
-        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));
-            return this;
-        }
-
-        /// <summary>
-        /// Add a rate lmit for the amount of requests per time for an endpoint
-        /// </summary>
-        /// <param name="endpoint">The endpoint 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>
-        /// <param name="method">The HttpMethod the limit is for, null for all</param>
-        /// <param name="ignoreOtherRateLimits">If set to true it ignores other rate limits</param>
-        /// <param name="countPerEndpoint">Whether all requests for this partial endpoint are bound to the same limit or each individual endpoint has its own limit</param>
-        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));
-            return this;
-        }
-
-        /// <summary>
-        /// Add a rate limit for the amount of requests per Api key
-        /// </summary>
-        /// <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>
-        /// <param name="onlyForSignedRequests">Only include calls that are signed in this limiter</param>
-        /// <param name="excludeFromTotalRateLimit">Exclude requests with API key from the total rate limiter</param>
-        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));
-            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)
-        {
-            int totalWaitTime = 0;
-
-            List<EndpointRateLimiter> endpointLimits;
-            lock (_limiterLock)
-                endpointLimits = _limiters.OfType<EndpointRateLimiter>().Where(h => h.Endpoints.Contains(endpoint) && (h.Method  == null || h.Method == method)).ToList();
-            foreach (var endpointLimit in endpointLimits)
-            {
-                var waitResult = await ProcessTopic(logger, endpointLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
-                if (!waitResult)
-                    return waitResult;
-
-                totalWaitTime += waitResult.Data;
-            }
-
-            if (endpointLimits.Any(l => l.IgnoreOtherRateLimits))
-                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();
-            foreach (var partialEndpointLimit in partialEndpointLimits)
-            {
-                if (partialEndpointLimit.CountPerEndpoint)
-                {
-                    SingleTopicRateLimiter? thisEndpointLimit;
-                    lock (_limiterLock)
-                    {
-                        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);
-                        }
-                    }
-
-                    var waitResult = await ProcessTopic(logger, thisEndpointLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
-                    if (!waitResult)
-                        return waitResult;
-
-                    totalWaitTime += waitResult.Data;
-                }
-                else
-                {
-                    var waitResult = await ProcessTopic(logger, partialEndpointLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
-                    if (!waitResult)
-                        return waitResult;
-
-                    totalWaitTime += waitResult.Data;
-                }
-            }
-
-            if(partialEndpointLimits.Any(p => p.IgnoreOtherRateLimits))
-                return new CallResult<int>(totalWaitTime);
-
-            List<ApiKeyRateLimiter> apiLimits;
-            lock (_limiterLock)
-                apiLimits = _limiters.OfType<ApiKeyRateLimiter>().Where(h => h.Type == RateLimitType.ApiKey).ToList();
-            foreach (var apiLimit in apiLimits)
-            {
-                if(apiKey == null)
-                {
-                    if (!apiLimit.OnlyForSignedRequests)
-                    {
-                        var waitResult = await ProcessTopic(logger, apiLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
-                        if (!waitResult)
-                            return waitResult;
-
-                        totalWaitTime += waitResult.Data;
-                    }
-                }
-                else if (signed || !apiLimit.OnlyForSignedRequests)
-                {
-                    SingleTopicRateLimiter? thisApiLimit;
-                    lock (_limiterLock)
-                    {
-                        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);
-                        }
-                    }
-
-                    var waitResult = await ProcessTopic(logger, thisApiLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
-                    if (!waitResult)
-                        return waitResult;
-
-                    totalWaitTime += waitResult.Data;
-                }
-            }
-
-            if ((signed || apiLimits.All(l => !l.OnlyForSignedRequests)) && apiLimits.Any(l => l.IgnoreTotalRateLimit))
-                return new CallResult<int>(totalWaitTime);
-
-            List<TotalRateLimiter> totalLimits;
-            lock (_limiterLock)
-                totalLimits = _limiters.OfType<TotalRateLimiter>().ToList();
-            foreach(var totalLimit in  totalLimits) 
-            {
-                var waitResult = await ProcessTopic(logger, totalLimit, endpoint, requestWeight, limitBehaviour, ct).ConfigureAwait(false);
-                if (!waitResult)
-                    return waitResult;
-
-                totalWaitTime += waitResult.Data;
-            }
-
-            return new CallResult<int>(totalWaitTime);
-        }
-
-        private static async Task<CallResult<int>> ProcessTopic(ILogger logger, Limiter historyTopic, string endpoint, int requestWeight, RateLimitingBehaviour limitBehaviour, CancellationToken ct)
-        {
-            var sw = Stopwatch.StartNew();
-            try
-            {
-                await historyTopic.Semaphore.WaitAsync(ct).ConfigureAwait(false);
-            }
-            catch (OperationCanceledException)
-            {
-                return new CallResult<int>(new CancellationRequestedError());
-            }
-            sw.Stop();
-
-            try
-            {
-                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++)
-                    {
-                        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;
-                        }
-                    }
-                    else
-                    {
-                        break;
-                    }
-                }
-
-                var newTime = DateTime.UtcNow;
-                historyTopic.Entries.Add(new LimitEntry(newTime, requestWeight));
-                return new CallResult<int>(totalWaitTime);
-            }
-            finally
-            {
-                historyTopic.Semaphore.Release();
-            }
-        }
-
-        internal struct LimitEntry
-        {
-            public DateTime Timestamp { get; set; }
-            public int Weight { get; set; }
-
-            public LimitEntry(DateTime timestamp, int weight)
-            {
-                Timestamp = timestamp;
-                Weight = weight;
-            }
-        }
-
-        internal class Limiter
-        {
-            public RateLimitType Type { get; set; }
-            public HttpMethod? Method { get; set; }
-
-            public SemaphoreSlim Semaphore { get; set; }
-            public int Limit { get; set; }
-
-            public TimeSpan Period { get; set; }
-            public List<LimitEntry> Entries { get; set; } = new List<LimitEntry>();
-
-            public Limiter(RateLimitType type, int limit, TimeSpan perPeriod, HttpMethod? method)
-            {
-                Semaphore = new SemaphoreSlim(1, 1);
-                Type = type;
-                Limit = limit;
-                Period = perPeriod;
-                Method = method;
-            }
-        }
-
-        internal class TotalRateLimiter : Limiter
-        {
-            public TotalRateLimiter(int limit, TimeSpan perPeriod, HttpMethod? method)
-                : base(RateLimitType.Total, limit, perPeriod, method)
-            {
-            }
-
-            public override string ToString()
-            {
-                return nameof(TotalRateLimiter);
-            }
-        }
-
-        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; }
-            public bool IgnoreOtherRateLimits { get; set; }
-
-            public EndpointRateLimiter(string[] endpoints, int limit, TimeSpan perPeriod, HttpMethod? method, bool ignoreOtherRateLimits)
-                :base(RateLimitType.Endpoint, limit, perPeriod, method)
-            {
-                Endpoints = endpoints;
-                IgnoreOtherRateLimits = ignoreOtherRateLimits;
-            }
-
-            public override string ToString()
-            {
-                return nameof(EndpointRateLimiter) + $": {string.Join(", ", Endpoints)}";
-            }
-        }
-
-        internal class PartialEndpointRateLimiter : Limiter
-        {
-            public string[] PartialEndpoints { get; set; }
-            public bool IgnoreOtherRateLimits { get; set; }
-            public bool CountPerEndpoint { get; set; }
-
-            public PartialEndpointRateLimiter(string[] partialEndpoints, int limit, TimeSpan perPeriod, HttpMethod? method, bool ignoreOtherRateLimits, bool countPerEndpoint)
-                : base(RateLimitType.PartialEndpoint, limit, perPeriod, method)
-            {
-                PartialEndpoints = partialEndpoints;
-                IgnoreOtherRateLimits = ignoreOtherRateLimits;
-                CountPerEndpoint = countPerEndpoint;
-            }
-
-            public override string ToString()
-            {
-                return nameof(PartialEndpointRateLimiter) + $": {string.Join(", ", PartialEndpoints)}";
-            }
-        }
-
-        internal class ApiKeyRateLimiter : Limiter
-        {
-            public bool OnlyForSignedRequests { get; set; }
-            public bool IgnoreTotalRateLimit { get; set; }
-
-            public ApiKeyRateLimiter(int limit, TimeSpan perPeriod, HttpMethod? method, bool onlyForSignedRequests, bool ignoreTotalRateLimit)
-                :base(RateLimitType.ApiKey, limit, perPeriod, method)
-            {
-                OnlyForSignedRequests = onlyForSignedRequests;
-                IgnoreTotalRateLimit = ignoreTotalRateLimit;
-            }
-        }
-
-        internal class SingleTopicRateLimiter: Limiter
-        {
-            public object Topic { get; set; }
-
-            public SingleTopicRateLimiter(object topic, Limiter limiter)
-                :base(limiter.Type, limiter.Limit, limiter.Period, limiter.Method)
-            {
-                Topic = topic;
-            }
-
-            public override string ToString()
-            {
-                return (Type == RateLimitType.ApiKey ? nameof(ApiKeyRateLimiter): nameof(EndpointRateLimiter)) + $": {Topic}";
-            }
-        }
-
-        internal enum RateLimitType 
-        { 
-            Total,
-            Endpoint,
-            PartialEndpoint,
-            ApiKey
-        }
-    }
-}

CryptoExchange.Net/Objects/RequestDefinition.cs

@@ -0,0 +1,81 @@
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using System;
+using System.Net.Http;
+
+namespace CryptoExchange.Net.Objects
+{
+    /// <summary>
+    /// The definition of a rest request
+    /// </summary>
+    public class RequestDefinition
+    {
+        private string? _stringRep;
+
+        // Basics
+
+        /// <summary>
+        /// Path of the request
+        /// </summary>
+        public string Path { get; set; }
+        /// <summary>
+        /// Http method of the request
+        /// </summary>
+        public HttpMethod Method { get; set; }
+        /// <summary>
+        /// Is the request authenticated
+        /// </summary>
+        public bool Authenticated { get; set; }
+
+
+        // Formating
+
+        /// <summary>
+        /// The body format for this request
+        /// </summary>
+        public RequestBodyFormat? RequestBodyFormat { get; set; }
+        /// <summary>
+        /// The position of parameters for this request
+        /// </summary>
+        public HttpMethodParameterPosition? ParameterPosition { get; set; }
+        /// <summary>
+        /// The array serialization type for this request
+        /// </summary>
+        public ArrayParametersSerialization? ArraySerialization { get; set; }
+
+        // Rate limiting
+        
+        /// <summary>
+        /// Request weight
+        /// </summary>
+        public int Weight { get; set; } = 1;
+        /// <summary>
+        /// Rate limit gate to use
+        /// </summary>
+        public IRateLimitGate? RateLimitGate { get; set; }
+        /// <summary>
+        /// Rate limit for this specific endpoint
+        /// </summary>
+        public int? EndpointLimitCount { get; set; }
+        /// <summary>
+        /// Rate limit period for this specific endpoint
+        /// </summary>
+        public TimeSpan? EndpointLimitPeriod { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="path"></param>
+        /// <param name="method"></param>
+        public RequestDefinition(string path, HttpMethod method)
+        {
+            Path = path;
+            Method = method;
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return _stringRep ??= $"{Method} {Path}{(Authenticated ? " authenticated" : "")}";
+        }
+    }
+}

CryptoExchange.Net/Objects/RequestDefinitionCache.cs

@@ -0,0 +1,84 @@
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Net.Http;
+
+namespace CryptoExchange.Net.Objects
+{
+    /// <summary>
+    /// Request definitions cache
+    /// </summary>
+    public class RequestDefinitionCache
+    {
+        private readonly ConcurrentDictionary<string, RequestDefinition> _definitions = new();
+
+        /// <summary>
+        /// Get a definition if it is already in the cache or create a new definition and add it to the cache
+        /// </summary>
+        /// <param name="method">The HttpMethod</param>
+        /// <param name="path">Endpoint path</param>
+        /// <param name="authenticated">Endpoint is authenticated</param>
+        /// <returns></returns>
+        public RequestDefinition GetOrCreate(HttpMethod method, string path, bool authenticated = false)
+            => GetOrCreate(method, path, null, 0, authenticated, null, null, null, null, null);
+
+        /// <summary>
+        /// Get a definition if it is already in the cache or create a new definition and add it to the cache
+        /// </summary>
+        /// <param name="method">The HttpMethod</param>
+        /// <param name="path">Endpoint path</param>
+        /// <param name="rateLimitGate">The rate limit gate</param>
+        /// <param name="weight">Request weight</param>
+        /// <param name="authenticated">Endpoint is authenticated</param>
+        /// <returns></returns>
+        public RequestDefinition GetOrCreate(HttpMethod method, string path, IRateLimitGate rateLimitGate, int weight = 1, bool authenticated = false)
+            => GetOrCreate(method, path, rateLimitGate,  weight, authenticated, null, null, null, null, null);
+
+        /// <summary>
+        /// Get a definition if it is already in the cache or create a new definition and add it to the cache
+        /// </summary>
+        /// <param name="method">The HttpMethod</param>
+        /// <param name="path">Endpoint path</param>
+        /// <param name="rateLimitGate">The rate limit gate</param>
+        /// <param name="endpointLimitCount">The limit count for this specific endpoint</param>
+        /// <param name="endpointLimitPeriod">The period for the limit for this specific endpoint</param>
+        /// <param name="weight">Request weight</param>
+        /// <param name="authenticated">Endpoint is authenticated</param>
+        /// <param name="requestBodyFormat">Request body format</param>
+        /// <param name="parameterPosition">Parameter position</param>
+        /// <param name="arraySerialization">Array serialization type</param>
+        /// <returns></returns>
+        public RequestDefinition GetOrCreate(
+            HttpMethod method,
+            string path,
+            IRateLimitGate? rateLimitGate,
+            int weight,
+            bool authenticated,
+            int? endpointLimitCount = null,
+            TimeSpan? endpointLimitPeriod = null,
+            RequestBodyFormat? requestBodyFormat = null,
+            HttpMethodParameterPosition? parameterPosition = null,
+            ArrayParametersSerialization? arraySerialization = null)
+        {
+
+            if (!_definitions.TryGetValue(method + path, out var def))
+            {
+                def = new RequestDefinition(path, method)
+                {
+                    Authenticated = authenticated,
+                    EndpointLimitCount = endpointLimitCount,
+                    EndpointLimitPeriod = endpointLimitPeriod,
+                    RateLimitGate = rateLimitGate,
+                    Weight = weight,
+                    ArraySerialization = arraySerialization,
+                    RequestBodyFormat = requestBodyFormat,
+                    ParameterPosition = parameterPosition,
+                };
+                _definitions.TryAdd(method + path, def);
+            }
+
+            return def;
+        }
+    }
+}

CryptoExchange.Net/Objects/Sockets/DataEvent.cs

@@ -14,9 +14,14 @@ namespace CryptoExchange.Net.Objects.Sockets
         public DateTime Timestamp { get; set; }
 
         /// <summary>
-        /// The topic of the update, what symbol/asset etc..
+        /// The stream producing the update
         /// </summary>
-        public string? Topic { get; set; }
+        public string? StreamId { get; set; }
+
+        /// <summary>
+        /// The symbol the update is for
+        /// </summary>
+        public string? Symbol { get; set; }
 
         /// <summary>
         /// The original data that was received, only available when OutputOriginalData is set to true in the client options
@@ -33,10 +38,11 @@ namespace CryptoExchange.Net.Objects.Sockets
         /// </summary>
         public T Data { get; set; }
 
-        internal DataEvent(T data, string? topic, string? originalData, DateTime timestamp, SocketUpdateType? updateType)
+        internal DataEvent(T data, string? streamId, string? symbol, string? originalData, DateTime timestamp, SocketUpdateType? updateType)
         {
             Data = data;
-            Topic = topic;
+            StreamId = streamId;
+            Symbol = symbol;
             OriginalData = originalData;
             Timestamp = timestamp;
             UpdateType = updateType;
@@ -50,7 +56,7 @@ namespace CryptoExchange.Net.Objects.Sockets
         /// <returns></returns>
         public DataEvent<K> As<K>(K data)
         {
-            return new DataEvent<K>(data, Topic, OriginalData, Timestamp, UpdateType);
+            return new DataEvent<K>(data, StreamId, Symbol, OriginalData, Timestamp, UpdateType);
         }
 
         /// <summary>
@@ -58,11 +64,11 @@ namespace CryptoExchange.Net.Objects.Sockets
         /// </summary>
         /// <typeparam name="K">The type of the new data</typeparam>
         /// <param name="data">The new data</param>
-        /// <param name="topic">The new topic</param>
+        /// <param name="symbol">The new symbol</param>
         /// <returns></returns>
-        public DataEvent<K> As<K>(K data, string? topic)
+        public DataEvent<K> As<K>(K data, string? symbol)
         {
-            return new DataEvent<K>(data, topic, OriginalData, Timestamp, UpdateType);
+            return new DataEvent<K>(data, StreamId, symbol, OriginalData, Timestamp, UpdateType);
         }
 
         /// <summary>
@@ -70,12 +76,73 @@ namespace CryptoExchange.Net.Objects.Sockets
         /// </summary>
         /// <typeparam name="K">The type of the new data</typeparam>
         /// <param name="data">The new data</param>
-        /// <param name="topic">The new topic</param>
+        /// <param name="streamId">The new stream id</param>
+        /// <param name="symbol">The new symbol</param>
         /// <param name="updateType">The type of update</param>
         /// <returns></returns>
-        public DataEvent<K> As<K>(K data, string? topic, SocketUpdateType updateType)
+        public DataEvent<K> As<K>(K data, string streamId, string? symbol, SocketUpdateType updateType)
         {
-            return new DataEvent<K>(data, topic, OriginalData, Timestamp, updateType);
+            return new DataEvent<K>(data, streamId, symbol, OriginalData, Timestamp, updateType);
+        }
+
+        /// <summary>
+        /// Specify the symbol
+        /// </summary>
+        /// <param name="symbol"></param>
+        /// <returns></returns>
+        public DataEvent<T> WithSymbol(string symbol)
+        {
+            Symbol = symbol;
+            return this;
+        }
+
+        /// <summary>
+        /// Specify the update type
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public DataEvent<T> WithUpdateType(SocketUpdateType type)
+        {
+            UpdateType = type;
+            return this;
+        }
+
+        /// <summary>
+        /// Specify the stream id
+        /// </summary>
+        /// <param name="streamId"></param>
+        /// <returns></returns>
+        public DataEvent<T> WithStreamId(string streamId)
+        {
+            StreamId = streamId;
+            return this;
+        }
+
+        /// <summary>
+        /// Create a CallResult from this DataEvent
+        /// </summary>
+        /// <returns></returns>
+        public CallResult<T> ToCallResult()
+        {
+            return new CallResult<T>(Data, OriginalData, null);
+        }
+
+        /// <summary>
+        /// Create a CallResult from this DataEvent
+        /// </summary>
+        /// <returns></returns>
+        public CallResult<K> ToCallResult<K>(K data)
+        {
+            return new CallResult<K>(data, OriginalData, null);
+        }
+
+        /// <summary>
+        /// Create a CallResult from this DataEvent
+        /// </summary>
+        /// <returns></returns>
+        public CallResult<K> ToCallResult<K>(Error error)
+        {
+            return new CallResult<K>(default, OriginalData, error);
         }
     }
 }

CryptoExchange.Net/Objects/Sockets/WebSocketParameters.cs

@@ -1,4 +1,4 @@
-using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.RateLimiting.Interfaces;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -51,9 +51,13 @@ namespace CryptoExchange.Net.Objects.Sockets
         public TimeSpan? KeepAliveInterval { get; set; }
 
         /// <summary>
-        /// The rate limiters for the socket connection
+        /// The rate limiter for the socket connection
         /// </summary>
-        public IEnumerable<IRateLimiter>? RateLimiters { get; set; }
+        public IRateLimitGate? RateLimiter { get; set; }
+        /// <summary>
+        /// What to do when rate limit is reached
+        /// </summary>
+        public RateLimitingBehaviour RateLimitingBehaviour { get; set; }
 
         /// <summary>
         /// Encoding for sending/receiving data

CryptoExchange.Net/OrderBook/OrderBookFactory.cs

@@ -0,0 +1,30 @@
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects.Options;
+using System;
+
+namespace CryptoExchange.Net.OrderBook
+{
+    /// <inheritdoc />
+    public class OrderBookFactory<TOptions> : IOrderBookFactory<TOptions> where TOptions: OrderBookOptions
+    {
+        private readonly Func<string, Action<TOptions>?, ISymbolOrderBook> _symbolCtor;
+        private readonly Func<string, string, Action<TOptions>?, ISymbolOrderBook> _assetsCtor;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="symbolCtor"></param>
+        /// <param name="assetsCtor"></param>
+        public OrderBookFactory(Func<string, Action<TOptions>?, ISymbolOrderBook> symbolCtor, Func<string, string, Action<TOptions>?, ISymbolOrderBook> assetsCtor)
+        {
+            _symbolCtor = symbolCtor;
+            _assetsCtor = assetsCtor;
+        }
+
+        /// <inheritdoc />
+        public ISymbolOrderBook Create(string symbol, Action<TOptions>? options = null) => _symbolCtor(symbol, options);
+
+        /// <inheritdoc />
+        public ISymbolOrderBook Create(string baseAsset, string quoteAsset, Action<TOptions>? options = null) => _assetsCtor(baseAsset, quoteAsset, options);
+    }
+}

CryptoExchange.Net/RateLimiting/Filters/AuthenticatedEndpointFilter.cs

@@ -0,0 +1,27 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using System.Security;
+
+namespace CryptoExchange.Net.RateLimiting.Filters
+{
+    /// <summary>
+    /// Filter requests based on whether they're authenticated or not
+    /// </summary>
+    public class AuthenticatedEndpointFilter : IGuardFilter
+    {
+        private readonly bool _authenticated;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="authenticated"></param>
+        public AuthenticatedEndpointFilter(bool authenticated)
+        {
+            _authenticated = authenticated;
+        }
+
+        /// <inheritdoc />
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+            => definition.Authenticated == _authenticated;
+    }
+}

CryptoExchange.Net/RateLimiting/Filters/ExactPathFilter.cs

@@ -0,0 +1,30 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Security;
+using System.Text;
+
+namespace CryptoExchange.Net.RateLimiting.Filters
+{
+    /// <summary>
+    /// Filter requests based on whether the request path matches a specific path
+    /// </summary>
+    public class ExactPathFilter : IGuardFilter
+    {
+        private readonly string _path;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="path"></param>
+        public ExactPathFilter(string path)
+        {
+            _path = path;
+        }
+
+        /// <inheritdoc />
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+            => string.Equals(definition.Path, _path, StringComparison.OrdinalIgnoreCase);
+    }
+}

CryptoExchange.Net/RateLimiting/Filters/ExactPathsFilter.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using System.Collections.Generic;
+using System.Security;
+
+namespace CryptoExchange.Net.RateLimiting.Filters
+{
+    /// <summary>
+    /// Filter requests based on whether the request path matches any specific path in a list
+    /// </summary>
+    public class ExactPathsFilter : IGuardFilter
+    {
+        private readonly HashSet<string> _paths;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="paths"></param>
+        public ExactPathsFilter(IEnumerable<string> paths)
+        {
+            _paths = new HashSet<string>(paths);
+        }
+
+        /// <inheritdoc />
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+            => _paths.Contains(definition.Path);
+    }
+}

CryptoExchange.Net/RateLimiting/Filters/HostFilter.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using System.Security;
+
+namespace CryptoExchange.Net.RateLimiting.Filters
+{
+    /// <summary>
+    /// Filter requests based on whether the host address matches a specific address
+    /// </summary>
+    public class HostFilter : IGuardFilter
+    {
+        private readonly string _host;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="host"></param>
+        public HostFilter(string host)
+        {
+            _host = host;
+        }
+
+        /// <inheritdoc />
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+            => host == _host;
+
+    }
+}

CryptoExchange.Net/RateLimiting/Filters/LimitItemTypeFilter.cs

@@ -0,0 +1,27 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using System.Security;
+
+namespace CryptoExchange.Net.RateLimiting.Filters
+{
+    /// <summary>
+    /// Filter requests based on whether it's a connection or a request
+    /// </summary>
+    public class LimitItemTypeFilter : IGuardFilter
+    {
+        private readonly RateLimitItemType _type;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="type"></param>
+        public LimitItemTypeFilter(RateLimitItemType type)
+        {
+            _type = type;
+        }
+
+        /// <inheritdoc />
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+            => type == _type;
+    }
+}

CryptoExchange.Net/RateLimiting/Filters/PathStartFilter.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using System;
+using System.Security;
+
+namespace CryptoExchange.Net.RateLimiting.Filters
+{
+    /// <summary>
+    /// Filter requests based on whether the path starts with a specific string
+    /// </summary>
+    public class PathStartFilter : IGuardFilter
+    {
+        private readonly string _path;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="path"></param>
+        public PathStartFilter(string path)
+        {
+            _path = path;
+        }
+
+        /// <inheritdoc />
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+            => definition.Path.StartsWith(_path, StringComparison.OrdinalIgnoreCase);
+    }
+}

CryptoExchange.Net/RateLimiting/Guards/RateLimitGuard.cs

@@ -0,0 +1,146 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using CryptoExchange.Net.RateLimiting.Trackers;
+using System;
+using System.Collections.Generic;
+using System.Security;
+using System.Text;
+
+namespace CryptoExchange.Net.RateLimiting.Guards
+{
+    /// <inheritdoc />
+    public class RateLimitGuard : IRateLimitGuard
+    {
+        /// <summary>
+        /// Apply guard per host
+        /// </summary>
+        public static Func<RequestDefinition, string, SecureString?, string> PerHost { get; } = new Func<RequestDefinition, string, SecureString?, string>((def, host, key) => host);
+        /// <summary>
+        /// Apply guard per endpoint
+        /// </summary>
+        public static Func<RequestDefinition, string, SecureString?, string> PerEndpoint { get; } = new Func<RequestDefinition, string, SecureString?, string>((def, host, key) => def.Path + def.Method);
+        /// <summary>
+        /// Apply guard per API key
+        /// </summary>
+        public static Func<RequestDefinition, string, SecureString?, string> PerApiKey { get; } = new Func<RequestDefinition, string, SecureString?, string>((def, host, key) => key!.GetString());
+        /// <summary>
+        /// Apply guard per API key per endpoint
+        /// </summary>
+        public static Func<RequestDefinition, string, SecureString?, string> PerApiKeyPerEndpoint { get; } = new Func<RequestDefinition, string, SecureString?, string>((def, host, key) => key!.GetString() + def.Path + def.Method);
+
+        private readonly IEnumerable<IGuardFilter> _filters;
+        private readonly Dictionary<string, IWindowTracker> _trackers;
+        private RateLimitWindowType _windowType;
+        private double? _decayRate;
+        private int? _connectionWeight;
+        private readonly Func<RequestDefinition, string, SecureString?, string> _keySelector;
+
+        /// <inheritdoc />
+        public string Name => "RateLimitGuard";
+
+        /// <inheritdoc />
+        public string Description => _windowType == RateLimitWindowType.Decay ? $"Limit of {Limit} with a decay rate of {_decayRate}" : $"Limit of {Limit} per {TimeSpan}";
+
+        /// <summary>
+        /// The limit per period
+        /// </summary>
+        public int Limit { get; }
+        /// <summary>
+        /// The time period for the limit
+        /// </summary>
+        public TimeSpan TimeSpan { get; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="keySelector">The rate limit key selector</param>
+        /// <param name="filter">Filter for rate limit items. Only when the rate limit item passes the filter the guard will apply</param>
+        /// <param name="limit">Limit per period</param>
+        /// <param name="timeSpan">Timespan for the period</param>
+        /// <param name="windowType">Type of rate limit window</param>
+        /// <param name="decayPerTimeSpan">The decay per timespan if windowType is DecayWindowTracker</param>
+        /// <param name="connectionWeight">The weight of a new connection</param>
+        public RateLimitGuard(Func<RequestDefinition, string, SecureString?, string> keySelector, IGuardFilter filter, int limit, TimeSpan timeSpan, RateLimitWindowType windowType, double? decayPerTimeSpan = null, int? connectionWeight = null)
+            : this(keySelector, new[] { filter }, limit, timeSpan, windowType, decayPerTimeSpan, connectionWeight)
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="keySelector">The rate limit key selector</param>
+        /// <param name="filters">Filters for rate limit items. Only when the rate limit item passes all filters the guard will apply</param>
+        /// <param name="limit">Limit per period</param>
+        /// <param name="timeSpan">Timespan for the period</param>
+        /// <param name="windowType">Type of rate limit window</param>
+        /// <param name="decayPerTimeSpan">The decay per timespan if windowType is DecayWindowTracker</param>
+        /// <param name="connectionWeight">The weight of a new connection</param>
+        public RateLimitGuard(Func<RequestDefinition, string, SecureString?, string> keySelector, IEnumerable<IGuardFilter> filters, int limit, TimeSpan timeSpan, RateLimitWindowType windowType, double? decayPerTimeSpan = null, int? connectionWeight = null)
+        {
+            _filters = filters;
+            _trackers = new Dictionary<string, IWindowTracker>();
+            _windowType = windowType;
+            Limit = limit;
+            TimeSpan = timeSpan;
+            _keySelector = keySelector;
+            _decayRate = decayPerTimeSpan;
+            _connectionWeight = connectionWeight;
+        }
+
+        /// <inheritdoc />
+        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        {
+            foreach(var filter in _filters)
+            {
+                if (!filter.Passes(type, definition, host, apiKey))
+                    return LimitCheck.NotApplicable;
+            }
+
+            if (type == RateLimitItemType.Connection)
+                requestWeight = _connectionWeight ?? requestWeight;
+
+            var key = _keySelector(definition, host, apiKey);
+            if (!_trackers.TryGetValue(key, out var tracker))
+            {
+                tracker = CreateTracker();
+                _trackers.Add(key, tracker);
+            }
+
+            var delay = tracker.GetWaitTime(requestWeight);
+            if (delay == default)
+                return LimitCheck.NotNeeded;
+
+            return LimitCheck.Needed(delay, Limit, TimeSpan, tracker.Current);
+        }
+
+        /// <inheritdoc />
+        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        {
+            foreach (var filter in _filters)
+            {
+                if (!filter.Passes(type, definition, host, apiKey))
+                    return RateLimitState.NotApplied;
+            }
+
+            if (type == RateLimitItemType.Connection)
+                requestWeight = _connectionWeight ?? requestWeight;
+
+            var key = _keySelector(definition, host, apiKey);
+            var tracker = _trackers[key];
+            tracker.ApplyWeight(requestWeight);
+            return RateLimitState.Applied(Limit, TimeSpan, tracker.Current);
+        }
+
+        /// <summary>
+        /// Create a new WindowTracker
+        /// </summary>
+        /// <returns></returns>
+        protected IWindowTracker CreateTracker()
+        {
+            return _windowType == RateLimitWindowType.Sliding ? new SlidingWindowTracker(Limit, TimeSpan)
+                : _windowType == RateLimitWindowType.Fixed ? new FixedWindowTracker(Limit, TimeSpan)
+                : _windowType == RateLimitWindowType.FixedAfterFirst ? new FixedAfterStartWindowTracker(Limit, TimeSpan) :
+                new DecayWindowTracker(Limit, TimeSpan, _decayRate ?? throw new InvalidOperationException("Decay rate not provided"));
+        }
+    }
+}

CryptoExchange.Net/RateLimiting/Guards/RetryAfterGuard.cs

@@ -0,0 +1,62 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Security;
+using System.Text;
+
+namespace CryptoExchange.Net.RateLimiting.Guards
+{
+    /// <summary>
+    /// Retry after guard
+    /// </summary>
+    public class RetryAfterGuard : IRateLimitGuard
+    {
+        /// <summary>
+        /// Additional wait time to apply to account for time offset between server and client
+        /// </summary>
+        private static readonly TimeSpan _windowBuffer = TimeSpan.FromMilliseconds(1000);
+
+        /// <inheritdoc />
+        public string Name => "RetryAfterGuard";
+
+        /// <inheritdoc />
+        public string Description => $"Pause requests until after {After}";
+
+        /// <summary>
+        /// The timestamp after which requests are allowed again
+        /// </summary>
+        public DateTime After { get; private set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="after"></param>
+        public RetryAfterGuard(DateTime after)
+        {
+            After = after;
+        }
+
+        /// <inheritdoc />
+        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        {
+            var dif = (After + _windowBuffer) - DateTime.UtcNow;
+            if (dif <= TimeSpan.Zero)
+                return LimitCheck.NotApplicable;
+
+            return LimitCheck.Needed(dif, default, default, default);
+        }
+
+        /// <inheritdoc />
+        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        {
+            return RateLimitState.NotApplied;
+        }
+
+        /// <summary>
+        /// Update the 'after' time
+        /// </summary>
+        /// <param name="after"></param>
+        public void UpdateAfter(DateTime after) => After = after;
+    }
+}

CryptoExchange.Net/RateLimiting/Guards/SingleLimitGuard.cs

@@ -0,0 +1,72 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using CryptoExchange.Net.RateLimiting.Trackers;
+using System;
+using System.Collections.Generic;
+using System.Security;
+
+namespace CryptoExchange.Net.RateLimiting.Guards
+{
+    /// <summary>
+    /// Rate limit guard for a per endpoint limit
+    /// </summary>
+    public class SingleLimitGuard : IRateLimitGuard
+    {
+        private readonly Dictionary<string, IWindowTracker> _trackers;
+        private readonly RateLimitWindowType _windowType;
+        private readonly double? _decayRate;
+
+        /// <inheritdoc />
+        public string Name => "EndpointLimitGuard";
+
+        /// <inheritdoc />
+        public string Description => $"Limit requests to endpoint";
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public SingleLimitGuard(RateLimitWindowType windowType, double? decayRate = null)
+        {
+            _windowType = windowType;
+            _decayRate = decayRate;
+            _trackers = new Dictionary<string, IWindowTracker>();
+        }
+
+        /// <inheritdoc />
+        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        {
+            var key = definition.Path + definition.Method;
+            if (!_trackers.TryGetValue(key, out var tracker))
+            {
+                tracker = CreateTracker(definition.EndpointLimitCount!.Value, definition.EndpointLimitPeriod!.Value);
+                _trackers.Add(key, tracker);
+            }
+
+            var delay = tracker.GetWaitTime(requestWeight);
+            if (delay == default)
+                return LimitCheck.NotNeeded;
+
+            return LimitCheck.Needed(delay, definition.EndpointLimitCount!.Value, definition.EndpointLimitPeriod!.Value, tracker.Current);
+        }
+
+        /// <inheritdoc />
+        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        {
+            var key = definition.Path + definition.Method;
+            var tracker = _trackers[key];
+            tracker.ApplyWeight(requestWeight);
+            return RateLimitState.Applied(definition.EndpointLimitCount!.Value, definition.EndpointLimitPeriod!.Value, tracker.Current);
+        }
+
+        /// <summary>
+        /// Create a new WindowTracker
+        /// </summary>
+        /// <returns></returns>
+        protected IWindowTracker CreateTracker(int limit, TimeSpan timeSpan)
+        {
+            return _windowType == RateLimitWindowType.Sliding ? new SlidingWindowTracker(limit, timeSpan)
+                : _windowType == RateLimitWindowType.Fixed ? new FixedWindowTracker(limit, timeSpan) :
+                new DecayWindowTracker(limit, timeSpan, _decayRate ?? throw new InvalidOperationException("Decay rate not provided"));
+        }
+    }
+}

CryptoExchange.Net/RateLimiting/Interfaces/IGuardFilter.cs

@@ -0,0 +1,21 @@
+using CryptoExchange.Net.Objects;
+using System.Security;
+
+namespace CryptoExchange.Net.RateLimiting.Interfaces
+{
+    /// <summary>
+    /// Filter requests based on specific condition
+    /// </summary>
+    public interface IGuardFilter
+    {
+        /// <summary>
+        /// Whether a request or connection passes this filter
+        /// </summary>
+        /// <param name="type">The type of item</param>
+        /// <param name="definition">The request definition</param>
+        /// <param name="host">The host address</param>
+        /// <param name="apiKey">The API key</param>
+        /// <returns>True if passed</returns>
+        bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey);
+    }
+}

CryptoExchange.Net/RateLimiting/Interfaces/IRateLimitGate.cs

@@ -0,0 +1,78 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.RateLimiting.Guards;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Security;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.RateLimiting.Interfaces
+{
+    /// <summary>
+    /// Rate limit gate
+    /// </summary>
+    public interface IRateLimitGate
+    {
+        /// <summary>
+        /// Event when the rate limit is triggered
+        /// </summary>
+        event Action<RateLimitEvent> RateLimitTriggered;
+
+        /// <summary>
+        /// Add a rate limit guard
+        /// </summary>
+        /// <param name="guard">Guard to add</param>
+        /// <returns></returns>
+        IRateLimitGate AddGuard(IRateLimitGuard guard);
+
+        /// <summary>
+        /// Set a RetryAfter guard, can be used when a server rate limit is hit and a RetryAfter header is specified
+        /// </summary>
+        /// <param name="retryAfter">The time after which requests can be send again</param>
+        /// <returns></returns>
+        Task SetRetryAfterGuardAsync(DateTime retryAfter);
+
+        /// <summary>
+        /// Set the SingleLimitGuard for handling individual endpoint rate limits
+        /// </summary>
+        /// <param name="guard"></param>
+        /// <returns></returns>
+        IRateLimitGate SetSingleLimitGuard(SingleLimitGuard guard);
+
+        /// <summary>
+        /// Returns the 'retry after' timestamp if set
+        /// </summary>
+        /// <returns></returns>
+        Task<DateTime?> GetRetryAfterTime();
+
+        /// <summary>
+        /// Process a request. Enforces the configured rate limits. When a rate limit is hit will wait for the rate limit to pass if RateLimitingBehaviour is Wait, or return an error if it is set to Fail
+        /// </summary>
+        /// <param name="logger">Logger</param>
+        /// <param name="itemId">Id of the item to check</param>
+        /// <param name="type">The rate limit item type</param>
+        /// <param name="definition">The request definition</param>
+        /// <param name="baseAddress">The host address</param>
+        /// <param name="apiKey">The API key</param>
+        /// <param name="requestWeight">Request weight</param>
+        /// <param name="behaviour">Behaviour when rate limit is hit</param>
+        /// <param name="ct">Cancelation token</param>
+        /// <returns>Error if RateLimitingBehaviour is Fail and rate limit is hit</returns>
+        Task<CallResult> ProcessAsync(ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string baseAddress, SecureString? apiKey, int requestWeight, RateLimitingBehaviour behaviour, CancellationToken ct);
+
+        /// <summary>
+        /// Enforces the rate limit as defined in the request definition. When a rate limit is hit will wait for the rate limit to pass if RateLimitingBehaviour is Wait, or return an error if it is set to Fail
+        /// </summary>
+        /// <param name="logger">Logger</param>
+        /// <param name="itemId">Id of the item to check</param>
+        /// <param name="type">The rate limit item type</param>
+        /// <param name="definition">The request definition</param>
+        /// <param name="baseAddress">The host address</param>
+        /// <param name="apiKey">The API key</param>
+        /// <param name="requestWeight">Request weight</param>
+        /// <param name="behaviour">Behaviour when rate limit is hit</param>
+        /// <param name="ct">Cancelation token</param>
+        /// <returns>Error if RateLimitingBehaviour is Fail and rate limit is hit</returns>
+        Task<CallResult> ProcessSingleAsync(ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string baseAddress, SecureString? apiKey, int requestWeight, RateLimitingBehaviour behaviour, CancellationToken ct);
+    }
+}

CryptoExchange.Net/RateLimiting/Interfaces/IRateLimitGuard.cs

@@ -0,0 +1,44 @@
+using CryptoExchange.Net.Objects;
+using System.Net.Http;
+using System.Security;
+
+namespace CryptoExchange.Net.RateLimiting.Interfaces
+{
+    /// <summary>
+    /// Rate limit guard
+    /// </summary>
+    public interface IRateLimitGuard
+    {
+        /// <summary>
+        /// Name
+        /// </summary>
+        string Name { get; }
+
+        /// <summary>
+        /// Description
+        /// </summary>
+        string Description { get; }
+
+        /// <summary>
+        /// Check whether a request can pass this rate limit guard
+        /// </summary>
+        /// <param name="type">The rate limit item type</param>
+        /// <param name="definition">The request definition</param>
+        /// <param name="host">The host address</param>
+        /// <param name="apiKey">The API key</param>
+        /// <param name="requestWeight">The request weight</param>
+        /// <returns></returns>
+        LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight);
+
+        /// <summary>
+        /// Apply the request to this guard with the specified weight
+        /// </summary>
+        /// <param name="type">The rate limit item type</param>
+        /// <param name="definition">The request definition</param>
+        /// <param name="host">The host address</param>
+        /// <param name="apiKey">The API key</param>
+        /// <param name="requestWeight">The request weight</param>
+        /// <returns></returns>
+        RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight);
+    }
+}

CryptoExchange.Net/RateLimiting/Interfaces/IWindowTracker.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace CryptoExchange.Net.RateLimiting.Interfaces
+{
+    /// <summary>
+    /// Rate limit window tracker
+    /// </summary>
+    public interface IWindowTracker
+    {
+        /// <summary>
+        /// Time period the limit is for
+        /// </summary>
+        TimeSpan TimePeriod { get; }
+        /// <summary>
+        /// The limit in the time period
+        /// </summary>
+        int Limit { get; }
+        /// <summary>
+        /// The current count within the time period
+        /// </summary>
+        int Current { get; }
+        /// <summary>
+        /// Get the time to wait to fit the weight
+        /// </summary>
+        /// <param name="weight"></param>
+        /// <returns></returns>
+        TimeSpan GetWaitTime(int weight);
+        /// <summary>
+        /// Register the weight in this window
+        /// </summary>
+        /// <param name="weight">Request weight</param>
+        void ApplyWeight(int weight);
+    }
+}

CryptoExchange.Net/RateLimiting/LimitCheck.cs

@@ -0,0 +1,60 @@
+using System;
+
+namespace CryptoExchange.Net.RateLimiting
+{
+    /// <summary>
+    /// Limit check
+    /// </summary>
+    public readonly struct LimitCheck
+    {
+        /// <summary>
+        /// Is guard applicable
+        /// </summary>
+        public bool Applicable { get; }
+        /// <summary>
+        /// Delay needed
+        /// </summary>
+        public TimeSpan Delay { get; }
+        /// <summary>
+        /// Current counter
+        /// </summary>
+        public int Current { get; }
+        /// <summary>
+        /// Limit
+        /// </summary>
+        public int? Limit { get; }
+        /// <summary>
+        /// Time period
+        /// </summary>
+        public TimeSpan? Period { get; }
+
+        private LimitCheck(bool applicable, TimeSpan delay, int limit, TimeSpan period, int current)
+        {
+            Applicable = applicable;
+            Delay = delay;
+            Limit = limit;
+            Period = period;
+            Current = current;
+        }
+
+        /// <summary>
+        /// Not applicable
+        /// </summary>
+        public static LimitCheck NotApplicable { get; } = new LimitCheck(false, default, default, default, default);
+
+        /// <summary>
+        /// No wait needed
+        /// </summary>
+        public static LimitCheck NotNeeded { get; } = new LimitCheck(true, default, default, default, default);
+
+        /// <summary>
+        /// Wait needed
+        /// </summary>
+        /// <param name="delay">The delay needed</param>
+        /// <param name="limit">Limit per period</param>
+        /// <param name="period">Period the limit is for</param>
+        /// <param name="current">Current counter</param>
+        /// <returns></returns>
+        public static LimitCheck Needed(TimeSpan delay, int limit, TimeSpan period, int current) => new(true, delay, limit, period, current);
+    }
+}

CryptoExchange.Net/RateLimiting/LimitEntry.cs

@@ -0,0 +1,30 @@
+using System;
+
+namespace CryptoExchange.Net.RateLimiting
+{
+    /// <summary>
+    /// A rate limit entry
+    /// </summary>
+    public struct LimitEntry
+    {
+        /// <summary>
+        /// Timestamp of the item
+        /// </summary>
+        public DateTime Timestamp { get; set; }
+        /// <summary>
+        /// Item weight
+        /// </summary>
+        public int Weight { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="timestamp"></param>
+        /// <param name="weight"></param>
+        public LimitEntry(DateTime timestamp, int weight)
+        {
+            Timestamp = timestamp;
+            Weight = weight;
+        }
+    }
+}

CryptoExchange.Net/RateLimiting/RateLimitEvent.cs

@@ -0,0 +1,80 @@
+using CryptoExchange.Net.Objects;
+using System;
+
+namespace CryptoExchange.Net.RateLimiting
+{
+    /// <summary>
+    /// Rate limit event
+    /// </summary>
+    public record RateLimitEvent
+    {
+        /// <summary>
+        /// Name of the API limit that is reached
+        /// </summary>
+        public string ApiLimit { get; set; } = string.Empty;
+        /// <summary>
+        /// Description of the limit that is reached
+        /// </summary>
+        public string LimitDescription { get; set; } = string.Empty;
+        /// <summary>
+        /// The request definition
+        /// </summary>
+        public RequestDefinition RequestDefinition { get; set; }
+        /// <summary>
+        /// The host the request is for
+        /// </summary>
+        public string Host { get; set; } = default!;
+        /// <summary>
+        /// The current counter value
+        /// </summary>
+        public int Current { get; set; }
+        /// <summary>
+        /// The weight of the limited request
+        /// </summary>
+        public int RequestWeight { get; set; }
+        /// <summary>
+        /// The limit per time period
+        /// </summary>
+        public int? Limit { get; set; }
+        /// <summary>
+        /// The time period the limit is for
+        /// </summary>
+        public TimeSpan? TimePeriod { get; set; }
+        /// <summary>
+        /// The time the request will be delayed for if the Behaviour is RateLimitingBehaviour.Wait
+        /// </summary>
+        public TimeSpan? DelayTime { get; set; }
+        /// <summary>
+        /// The handling behaviour for the rquest 
+        /// </summary>
+        public RateLimitingBehaviour Behaviour { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="apiLimit"></param>
+        /// <param name="limitDescription"></param>
+        /// <param name="definition"></param>
+        /// <param name="host"></param>
+        /// <param name="current"></param>
+        /// <param name="requestWeight"></param>
+        /// <param name="limit"></param>
+        /// <param name="timePeriod"></param>
+        /// <param name="delayTime"></param>
+        /// <param name="behaviour"></param>
+        public RateLimitEvent(string apiLimit, string limitDescription, RequestDefinition definition, string host, int current, int requestWeight, int? limit, TimeSpan? timePeriod, TimeSpan? delayTime, RateLimitingBehaviour behaviour)
+        {
+            ApiLimit = apiLimit;
+            LimitDescription = limitDescription;
+            RequestDefinition = definition;
+            Host = host;
+            Current = current;
+            RequestWeight = requestWeight;
+            Limit = limit;
+            TimePeriod = timePeriod;
+            DelayTime = delayTime;
+            Behaviour = behaviour;
+        }
+
+    }
+}

CryptoExchange.Net/RateLimiting/RateLimitGate.cs

@@ -0,0 +1,174 @@
+using CryptoExchange.Net.Logging.Extensions;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.RateLimiting.Guards;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.RateLimiting
+{
+    /// <inheritdoc />
+    public class RateLimitGate : IRateLimitGate
+    {
+        private IRateLimitGuard _singleLimitGuard = new SingleLimitGuard(RateLimitWindowType.Sliding);
+        private readonly ConcurrentBag<IRateLimitGuard> _guards;
+        private readonly SemaphoreSlim _semaphore;
+        private readonly string _name;
+
+        private int _waitingCount;
+
+        /// <inheritdoc />
+        public event Action<RateLimitEvent>? RateLimitTriggered;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public RateLimitGate(string name)
+        {
+            _name = name;
+            _guards = new ConcurrentBag<IRateLimitGuard>();
+            _semaphore = new SemaphoreSlim(1);
+        }
+
+        /// <inheritdoc />
+        public async Task<CallResult> ProcessAsync(ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight, RateLimitingBehaviour rateLimitingBehaviour, CancellationToken ct)
+        {
+            await _semaphore.WaitAsync(ct).ConfigureAwait(false);
+            _waitingCount++;
+            try
+            {
+                return await CheckGuardsAsync(_guards, logger, itemId, type, definition, host, apiKey, requestWeight, rateLimitingBehaviour, ct).ConfigureAwait(false);
+            }
+            finally
+            {
+                _waitingCount--;
+                _semaphore.Release();
+            }
+        }
+
+        /// <inheritdoc />
+        public async Task<CallResult> ProcessSingleAsync(ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight, RateLimitingBehaviour rateLimitingBehaviour, CancellationToken ct)
+        {
+            await _semaphore.WaitAsync(ct).ConfigureAwait(false);
+            if (requestWeight == 0)
+                requestWeight = 1;
+
+            _waitingCount++;
+            try
+            {
+                return await CheckGuardsAsync(new IRateLimitGuard[] { _singleLimitGuard }, logger, itemId, type, definition, host, apiKey, requestWeight, rateLimitingBehaviour, ct).ConfigureAwait(false);
+            }
+            finally
+            {
+                _waitingCount--;
+                _semaphore.Release();
+            }
+        }
+
+        private async Task<CallResult> CheckGuardsAsync(IEnumerable<IRateLimitGuard> guards, ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight, RateLimitingBehaviour rateLimitingBehaviour, CancellationToken ct)
+        {
+            foreach (var guard in guards)
+            {
+                // Check if a wait is needed for this guard
+                var result = guard.Check(type, definition, host, apiKey, requestWeight);
+                if (result.Delay != TimeSpan.Zero && rateLimitingBehaviour == RateLimitingBehaviour.Fail)
+                {
+                    // Delay is needed and limit behaviour is to fail the request
+                    if (type == RateLimitItemType.Connection)
+                        logger.RateLimitConnectionFailed(itemId, guard.Name, guard.Description);
+                    else
+                        logger.RateLimitRequestFailed(itemId, definition.Path, guard.Name, guard.Description);
+                    
+                    RateLimitTriggered?.Invoke(new RateLimitEvent(_name, guard.Description, definition, host, result.Current, requestWeight, result.Limit, result.Period, result.Delay, rateLimitingBehaviour));
+                    return new CallResult(new ClientRateLimitError($"Rate limit check failed on guard {guard.Name}; {guard.Description}"));
+                }
+
+                if (result.Delay != TimeSpan.Zero)
+                {
+                    // Delay is needed and limit behaviour is to wait for the request to be under the limit
+                    _semaphore.Release();
+
+                    var description = result.Limit == null ? guard.Description : $"{guard.Description}, Request weight: {requestWeight}, Current: {result.Current}, Limit: {result.Limit}, requests now being limited: {_waitingCount}";
+                    if (type == RateLimitItemType.Connection)
+                        logger.RateLimitDelayingConnection(itemId, result.Delay, guard.Name, description);
+                    else
+                        logger.RateLimitDelayingRequest(itemId, definition.Path, result.Delay, guard.Name, description);
+
+                    RateLimitTriggered?.Invoke(new RateLimitEvent(_name, guard.Description, definition, host, result.Current, requestWeight, result.Limit, result.Period, result.Delay, rateLimitingBehaviour));
+                    await Task.Delay(result.Delay, ct).ConfigureAwait(false);
+                    await _semaphore.WaitAsync(ct).ConfigureAwait(false);
+                    return await CheckGuardsAsync(guards, logger, itemId, type, definition, host, apiKey, requestWeight, rateLimitingBehaviour, ct).ConfigureAwait(false);
+                }
+            }
+
+            // Apply the weight on each guard
+            foreach (var guard in guards)
+            {
+                var result = guard.ApplyWeight(type, definition, host, apiKey, requestWeight);
+                if (result.IsApplied)
+                {
+                    if (type == RateLimitItemType.Connection)
+                        logger.RateLimitAppliedConnection(itemId, guard.Name, guard.Description, result.Current);
+                    else
+                        logger.RateLimitAppliedRequest(itemId, definition.Path, guard.Name, guard.Description, result.Current);
+                }
+            }
+
+            return new CallResult(null);
+        }
+
+        /// <inheritdoc />
+        public IRateLimitGate AddGuard(IRateLimitGuard guard)
+        {
+            _guards.Add(guard);
+            return this;
+        }
+
+        /// <inheritdoc />
+        public IRateLimitGate SetSingleLimitGuard(SingleLimitGuard guard)
+        {
+            _singleLimitGuard = guard;
+            return this;
+        }
+
+        /// <inheritdoc />
+        public async Task SetRetryAfterGuardAsync(DateTime retryAfter)
+        {
+            await _semaphore.WaitAsync().ConfigureAwait(false);
+
+            try
+            {
+                var retryAfterGuard = _guards.OfType<RetryAfterGuard>().SingleOrDefault();
+                if (retryAfterGuard == null)
+                    _guards.Add(new RetryAfterGuard(retryAfter));
+                else
+                    retryAfterGuard.UpdateAfter(retryAfter);
+            }
+            finally
+            {
+                _semaphore.Release();
+            }
+        }
+
+        /// <inheritdoc />
+        public async Task<DateTime?> GetRetryAfterTime()
+        {
+            await _semaphore.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                var retryAfterGuard = _guards.OfType<RetryAfterGuard>().SingleOrDefault();
+                return retryAfterGuard?.After;
+            }
+            finally
+            {
+                _semaphore.Release();
+            }
+        }
+    }
+}

CryptoExchange.Net/RateLimiting/RateLimitItemType.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace CryptoExchange.Net.RateLimiting
+{
+    /// <summary>
+    /// Rate limit item type
+    /// </summary>
+    [Flags]
+    public enum RateLimitItemType
+    {
+        /// <summary>
+        /// A connection attempt
+        /// </summary>
+        Connection = 1,
+        /// <summary>
+        /// A request
+        /// </summary>
+        Request = 2
+    }
+}

CryptoExchange.Net/RateLimiting/RateLimitState.cs

@@ -0,0 +1,55 @@
+using System;
+
+namespace CryptoExchange.Net.RateLimiting
+{
+    /// <summary>
+    /// Limit state
+    /// </summary>
+    public struct RateLimitState
+    {
+        /// <summary>
+        /// Limit
+        /// </summary>
+        public int Limit { get; }
+        /// <summary>
+        /// Period 
+        /// </summary>
+        public TimeSpan Period { get; }
+        /// <summary>
+        /// Current count
+        /// </summary>
+        public int Current { get; }
+        /// <summary>
+        /// Whether the limit is applied
+        /// </summary>
+        public bool IsApplied { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="applied"></param>
+        /// <param name="limit"></param>
+        /// <param name="period"></param>
+        /// <param name="current"></param>
+        public RateLimitState(bool applied, int limit, TimeSpan period, int current)
+        {
+            IsApplied = applied;
+            Limit = limit;
+            Period = period;
+            Current = current;
+        }
+
+        /// <summary>
+        /// Not applied result
+        /// </summary>
+        public static RateLimitState NotApplied { get; } = new RateLimitState(false, default, default, default);
+        /// <summary>
+        /// Applied result
+        /// </summary>
+        /// <param name="limit"></param>
+        /// <param name="period"></param>
+        /// <param name="current"></param>
+        /// <returns></returns>
+        public static RateLimitState Applied(int limit, TimeSpan period, int current) => new RateLimitState(true, limit, period, current);
+    }
+}

CryptoExchange.Net/RateLimiting/Trackers/DecayWindowTracker.cs

@@ -0,0 +1,86 @@
+using System;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+
+namespace CryptoExchange.Net.RateLimiting.Trackers
+{
+    internal class DecayWindowTracker : IWindowTracker
+    {
+        /// <inheritdoc />
+        public TimeSpan TimePeriod { get; }
+        /// <summary>
+        /// Decrease rate per TimePeriod
+        /// </summary>
+        public double DecreaseRate { get; }
+        /// <inheritdoc />
+        public int Limit { get; }
+        /// <inheritdoc />
+        public int Current => _currentWeight;
+
+        private int _currentWeight = 0;
+        private DateTime _lastDecrease = DateTime.UtcNow;
+
+        public DecayWindowTracker(int limit, TimeSpan period, double decayRate)
+        {
+            Limit = limit;
+            TimePeriod = period;
+            DecreaseRate = decayRate;
+        }
+
+        /// <inheritdoc />
+        public TimeSpan GetWaitTime(int weight)
+        {
+            // Decrease the counter based on the last update time and decay rate
+            DecreaseCounter(DateTime.UtcNow);
+
+            if (Current + weight > Limit)
+            {
+                // The weight would cause the rate limit to be passed
+                if (Current == 0)
+                {
+                    throw new Exception("Request limit reached without any prior request. " +
+                        $"This request can never execute with the current rate limiter. Request weight: {weight}, Ratelimit: {Limit}");
+                }
+
+                // Determine the time to wait before this weight can be applied without going over the rate limit
+                return DetermineWaitTime(weight);
+            }
+
+            // Weight can fit without going over limit
+            return TimeSpan.Zero;
+        }
+
+        /// <inheritdoc />
+        public void ApplyWeight(int weight)
+        {
+            if (_currentWeight == 0)
+                _lastDecrease = DateTime.UtcNow;
+            _currentWeight += weight;
+        }
+
+        /// <summary>
+        /// Decrease the counter based on time passed since last update and the decay rate
+        /// </summary>
+        /// <param name="time"></param>
+        protected void DecreaseCounter(DateTime time)
+        {
+            var dif = (time - _lastDecrease).TotalMilliseconds / TimePeriod.TotalMilliseconds * DecreaseRate;
+            var decrease = (int)Math.Floor(dif);
+            if (decrease >= 1)
+            {
+                _currentWeight = Math.Max(0, _currentWeight - (int)Math.Floor(dif));
+                _lastDecrease = time;
+            }
+        }
+
+        /// <summary>
+        /// Determine the time to wait before the weight would fit
+        /// </summary>
+        /// <param name="requestWeight"></param>
+        /// <returns></returns>
+        private TimeSpan DetermineWaitTime(int requestWeight)
+        {
+            var weightToRemove = Math.Max(Current - (Limit - requestWeight), 0);
+            return TimeSpan.FromMilliseconds(Math.Ceiling(weightToRemove / DecreaseRate) * TimePeriod.TotalMilliseconds);
+        }
+    }
+}

CryptoExchange.Net/RateLimiting/Trackers/FixedAfterStartWindowTracker.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+
+namespace CryptoExchange.Net.RateLimiting.Trackers
+{
+    internal class FixedAfterStartWindowTracker : IWindowTracker
+    {
+        /// <inheritdoc />
+        public TimeSpan TimePeriod { get; }
+        /// <inheritdoc />
+        public int Limit { get; }
+        /// <inheritdoc />
+        public int Current => _currentWeight;
+
+        private readonly Queue<LimitEntry> _entries;
+        private int _currentWeight = 0;
+        private DateTime? _nextReset;
+
+        /// <summary>
+        /// Additional wait time to apply to account for time offset between server and client
+        /// </summary>
+        private static TimeSpan _fixedWindowBuffer = TimeSpan.FromMilliseconds(1000);
+
+        public FixedAfterStartWindowTracker(int limit, TimeSpan period)
+        {
+            Limit = limit;
+            TimePeriod = period;
+            _entries = new Queue<LimitEntry>();
+        }
+
+        public TimeSpan GetWaitTime(int weight)
+        {
+            // Remove requests no longer in time period from the history
+            var checkTime = DateTime.UtcNow;
+            if (_nextReset != null && checkTime > _nextReset)
+                RemoveBefore(_nextReset.Value);
+
+            if (Current == 0)
+                _nextReset = null;
+
+            if (Current + weight > Limit)
+            {
+                // The weight would cause the rate limit to be passed
+                if (Current == 0)
+                {
+                    throw new Exception("Request limit reached without any prior request. " +
+                        $"This request can never execute with the current rate limiter. Request weight: {weight}, Ratelimit: {Limit}");
+                }
+
+                // Determine the time to wait before this weight can be applied without going over the rate limit
+                return DetermineWaitTime();
+            }
+
+            // Weight can fit without going over limit
+            return TimeSpan.Zero;
+        }
+
+        /// <inheritdoc />
+        public void ApplyWeight(int weight)
+        {
+            if (_currentWeight == 0)
+                _nextReset = DateTime.UtcNow + TimePeriod;
+            _currentWeight += weight;
+            _entries.Enqueue(new LimitEntry(DateTime.UtcNow, weight));
+        }
+
+        /// <summary>
+        /// Remove items before a certain time
+        /// </summary>
+        /// <param name="time"></param>
+        protected void RemoveBefore(DateTime time)
+        {
+            while (true)
+            {
+                if (_entries.Count == 0)
+                    break;
+
+                var firstItem = _entries.Peek();
+                if (firstItem.Timestamp < time)
+                {
+                    _entries.Dequeue();
+                    _currentWeight -= firstItem.Weight;
+                }
+                else
+                {
+                    // Either no entries left, or the entry time is still within the window
+                    break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Determine the time to wait before a new item would fit
+        /// </summary>
+        /// <returns></returns>
+        private TimeSpan DetermineWaitTime()
+        {
+            var checkTime = DateTime.UtcNow;
+            return (_nextReset!.Value - checkTime) + _fixedWindowBuffer;
+        }
+    }
+}

CryptoExchange.Net/RateLimiting/Trackers/FixedWindowTracker.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+
+namespace CryptoExchange.Net.RateLimiting.Trackers
+{
+    internal class FixedWindowTracker : IWindowTracker
+    {
+        /// <inheritdoc />
+        public TimeSpan TimePeriod { get; }
+        /// <inheritdoc />
+        public int Limit { get; }
+        /// <inheritdoc />
+        public int Current => _currentWeight;
+
+        private readonly Queue<LimitEntry> _entries;
+        private int _currentWeight = 0;
+
+        /// <summary>
+        /// Additional wait time to apply to account for time offset between server and client
+        /// </summary>
+        private static readonly TimeSpan _fixedWindowBuffer = TimeSpan.FromMilliseconds(1000);
+
+        public FixedWindowTracker(int limit, TimeSpan period)
+        {
+            Limit = limit;
+            TimePeriod = period;
+            _entries = new Queue<LimitEntry>();
+        }
+
+        /// <inheritdoc />
+        public TimeSpan GetWaitTime(int weight)
+        {
+            // Remove requests no longer in time period from the history
+            var checkTime = DateTime.UtcNow;
+            RemoveBefore(checkTime.AddTicks(-(checkTime.Ticks % TimePeriod.Ticks)));
+
+            if (Current + weight > Limit)
+            {
+                // The weight would cause the rate limit to be passed
+                if (Current == 0)
+                {
+                    throw new Exception("Request limit reached without any prior request. " +
+                        $"This request can never execute with the current rate limiter. Request weight: {weight}, Ratelimit: {Limit}");
+                }
+
+                // Determine the time to wait before this weight can be applied without going over the rate limit
+                return DetermineWaitTime();
+            }
+
+            // Weight can fit without going over limit
+            return TimeSpan.Zero;
+        }
+
+        /// <inheritdoc />
+        public void ApplyWeight(int weight)
+        {
+            _currentWeight += weight;
+            _entries.Enqueue(new LimitEntry(DateTime.UtcNow, weight));
+        }
+
+        /// <summary>
+        /// Remove items before a certain time
+        /// </summary>
+        /// <param name="time"></param>
+        protected void RemoveBefore(DateTime time)
+        {
+            while (true)
+            {
+                if (_entries.Count == 0)
+                    break;
+
+                var firstItem = _entries.Peek();
+                if (firstItem.Timestamp < time)
+                {
+                    _entries.Dequeue();
+                    _currentWeight -= firstItem.Weight;
+                }
+                else
+                {
+                    // Either no entries left, or the entry time is still within the window
+                    break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Determine the time to wait before a new item would fit
+        /// </summary>
+        /// <returns></returns>
+        private TimeSpan DetermineWaitTime()
+        {
+            var checkTime = DateTime.UtcNow;
+            var startCurrentWindow = checkTime.AddTicks(-(checkTime.Ticks % TimePeriod.Ticks));
+            var wait = startCurrentWindow.Add(TimePeriod) - checkTime;
+            return wait.Add(_fixedWindowBuffer);
+        }
+    }
+}

CryptoExchange.Net/RateLimiting/Trackers/SlidingWindowTracker.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+
+namespace CryptoExchange.Net.RateLimiting.Trackers
+{
+    internal class SlidingWindowTracker : IWindowTracker
+    {
+        /// <inheritdoc />
+        public TimeSpan TimePeriod { get; }
+        /// <inheritdoc />
+        public int Limit { get; }
+        /// <inheritdoc />
+        public int Current => _currentWeight;
+
+        private readonly List<LimitEntry> _entries;
+        private int _currentWeight = 0;
+
+        public SlidingWindowTracker(int limit, TimeSpan period)
+        {
+            Limit = limit;
+            TimePeriod = period;
+            _entries = new List<LimitEntry>();
+        }
+
+        /// <inheritdoc />
+        public TimeSpan GetWaitTime(int weight)
+        {
+            // Remove requests no longer in time period from the history
+            RemoveBefore(DateTime.UtcNow - TimePeriod);
+
+            if (Current + weight > Limit)
+            {
+                // The weight would cause the rate limit to be passed
+                if (Current == 0)
+                {
+                    throw new Exception("Request limit reached without any prior request. " +
+                        $"This request can never execute with the current rate limiter. Request weight: {weight}, Ratelimit: {Limit}");
+                }
+
+                // Determine the time to wait before this weight can be applied without going over the rate limit
+                return DetermineWaitTime(weight);
+            }
+
+            // Weight can fit without going over limit
+            return TimeSpan.Zero;
+        }
+
+        /// <inheritdoc />
+        public void ApplyWeight(int weight)
+        {
+            _currentWeight += weight;
+            _entries.Add(new LimitEntry(DateTime.UtcNow, weight));
+        }
+
+        /// <summary>
+        /// Remove items before a certain time
+        /// </summary>
+        /// <param name="time"></param>
+        protected void RemoveBefore(DateTime time)
+        {
+            for (var i = 0; i < _entries.Count; i++)
+            {
+                if (_entries[i].Timestamp < time)
+                {
+                    var entry = _entries[i];
+                    _entries.Remove(entry);
+                    _currentWeight -= entry.Weight;
+                    i--;
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Determine the time to wait before the weight would fit
+        /// </summary>
+        /// <returns></returns>
+        private TimeSpan DetermineWaitTime(int requestWeight)
+        {
+            var weightToRemove = Math.Max(Current - (Limit - requestWeight), 0);
+            var removedWeight = 0;
+            for (var i = 0; i < _entries.Count; i++)
+            {
+                var entry = _entries[i];
+                removedWeight += entry.Weight;
+                if (removedWeight >= weightToRemove)
+                {
+                    return entry.Timestamp + TimePeriod - DateTime.UtcNow;
+                }
+            }
+
+            throw new Exception("Request not possible to execute with current rate limit guard. " +
+                        $" Request weight: {requestWeight}, Ratelimit: {Limit}");
+        }
+    }
+}

CryptoExchange.Net/Requests/RequestFactory.cs

@@ -19,6 +19,7 @@ namespace CryptoExchange.Net.Requests
             if (client == null)
             {
                 var handler = new HttpClientHandler();
+                handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
                 if (proxy != null)
                 {
                     handler.Proxy = new WebProxy

CryptoExchange.Net/Sockets/CryptoExchangeWebSocketClient.cs

@@ -2,6 +2,7 @@
 using CryptoExchange.Net.Logging.Extensions;
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.RateLimiting;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Concurrent;
@@ -45,6 +46,7 @@ namespace CryptoExchange.Net.Sockets
         private bool _disposed;
         private ProcessState _processState;
         private DateTime _lastReconnectTime;
+        private string _baseAddress;
 
         private const int _receiveBufferSize = 1048576;
         private const int _sendBufferSize = 4096;
@@ -110,6 +112,9 @@ namespace CryptoExchange.Net.Sockets
         /// <inheritdoc />
         public event Func<int, Task>? OnRequestSent;
 
+        /// <inheritdoc />
+        public event Func<int, Task>? OnRequestRateLimited;
+
         /// <inheritdoc />
         public event Func<Exception, Task>? OnError;
 
@@ -143,17 +148,19 @@ namespace CryptoExchange.Net.Sockets
 
             _closeSem = new SemaphoreSlim(1, 1);
             _socket = CreateSocket();
+            _baseAddress = $"{Uri.Scheme}://{Uri.Host}";
         }
 
         /// <inheritdoc />
-        public virtual async Task<bool> ConnectAsync()
+        public virtual async Task<CallResult> ConnectAsync()
         {
-            if (!await ConnectInternalAsync().ConfigureAwait(false))
+            var connectResult = await ConnectInternalAsync().ConfigureAwait(false);
-                return false;
+            if (!connectResult)
+                return connectResult;
             
             await (OnOpen?.Invoke() ?? Task.CompletedTask).ConfigureAwait(false);
             _processTask = ProcessAsync();
-            return true;            
+            return connectResult;
         }
 
         /// <summary>
@@ -188,22 +195,35 @@ namespace CryptoExchange.Net.Sockets
             return socket;
         }
 
-        private async Task<bool> ConnectInternalAsync()
+        private async Task<CallResult> ConnectInternalAsync()
         {
             _logger.SocketConnecting(Id);
             try
             {
+                if (Parameters.RateLimiter != null)
+                {
+                    var definition = new RequestDefinition(Id.ToString(), HttpMethod.Get);
+                    var limitResult = await Parameters.RateLimiter.ProcessAsync(_logger, Id, RateLimitItemType.Connection, definition, _baseAddress, null, 1, Parameters.RateLimitingBehaviour, _ctsSource.Token).ConfigureAwait(false);
+                    if (!limitResult)
+                        return new CallResult(new ClientRateLimitError("Connection limit reached"));
+                }
+
                 using CancellationTokenSource tcs = new(TimeSpan.FromSeconds(10));
-                await _socket.ConnectAsync(Uri, tcs.Token).ConfigureAwait(false);
+                using var linked = CancellationTokenSource.CreateLinkedTokenSource(tcs.Token, _ctsSource.Token);
+                await _socket.ConnectAsync(Uri, linked.Token).ConfigureAwait(false);
             }
             catch (Exception e)
             {
-                _logger.SocketConnectionFailed(Id, e.Message, e);
+                if (!_ctsSource.IsCancellationRequested)
-                return false;
+                {
+                    // if _ctsSource was canceled this was already logged
+                    _logger.SocketConnectionFailed(Id, e.Message, e);
+                }
+                return new CallResult(new CantConnectError());
             }
 
             _logger.SocketConnected(Id, Uri);
-            return true;
+            return new CallResult(null);
         }
 
         /// <inheritdoc />
@@ -250,7 +270,7 @@ namespace CryptoExchange.Net.Sockets
                     if (task != null)
                     {
                         var reconnectUri = await task.ConfigureAwait(false);
-                        if (reconnectUri != null && Parameters.Uri != reconnectUri)
+                        if (reconnectUri != null && Parameters.Uri.ToString() != reconnectUri.ToString())
                         {
                             _logger.SocketSetReconnectUri(Id, reconnectUri);
                             Parameters.Uri = reconnectUri;
@@ -386,10 +406,13 @@ namespace CryptoExchange.Net.Sockets
             if (_disposed)
                 return;
 
+            if (_ctsSource?.IsCancellationRequested == false)
+                _ctsSource.Cancel();
+
             _logger.SocketDisposing(Id);
             _disposed = true;
             _socket.Dispose();
-            _ctsSource.Dispose();
+            _ctsSource?.Dispose();
             _logger.SocketDisposed(Id);
         }
 
@@ -399,9 +422,9 @@ namespace CryptoExchange.Net.Sockets
         /// <returns></returns>
         private async Task SendLoopAsync()
         {
+            var requestDefinition = new RequestDefinition(Id.ToString(), HttpMethod.Get);
             try
             {
-                var limitKey = Uri.ToString() + "/" + Id.ToString();
                 while (true)
                 {
                     if (_ctsSource.IsCancellationRequested)
@@ -414,16 +437,13 @@ namespace CryptoExchange.Net.Sockets
 
                     while (_sendBuffer.TryDequeue(out var data))
                     {
-                        if (Parameters.RateLimiters != null)
+                        if (Parameters.RateLimiter != null)
                         {
-                            foreach(var ratelimiter in Parameters.RateLimiters)
+                            var limitResult = await Parameters.RateLimiter.ProcessAsync(_logger, data.Id, RateLimitItemType.Request, requestDefinition, _baseAddress, null, data.Weight, Parameters.RateLimitingBehaviour, _ctsSource.Token).ConfigureAwait(false);
+                            if (!limitResult)
                             {
-                                var limitResult = await ratelimiter.LimitRequestAsync(_logger, limitKey, HttpMethod.Get, false, null, RateLimitingBehaviour.Wait, data.Weight, _ctsSource.Token).ConfigureAwait(false);
+                                await (OnRequestRateLimited?.Invoke(data.Id) ?? Task.CompletedTask).ConfigureAwait(false);
-                                if (limitResult.Success)
+                                continue;
-                                {
-                                    if (limitResult.Data > 0)
-                                        _logger.SocketSendDelayedBecauseOfRateLimit(Id, data.Id, limitResult.Data);
-                                }
                             }
                         }
 
@@ -709,7 +729,7 @@ namespace CryptoExchange.Net.Sockets
         public int Id { get; set; }
 
         /// <summary>
-        /// The request id
+        /// The request weight
         /// </summary>
         public int Weight { get; set; }
 

CryptoExchange.Net/Sockets/PeriodicTaskRegistration.cs

@@ -1,7 +1,5 @@
 using CryptoExchange.Net.Objects;
 using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace CryptoExchange.Net.Sockets
 {

CryptoExchange.Net/Sockets/Query.cs

@@ -1,9 +1,9 @@
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Requests;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -146,16 +146,17 @@ namespace CryptoExchange.Net.Sockets
     /// <summary>
     /// Query
     /// </summary>
-    /// <typeparam name="TResponse">Response object type</typeparam>
+    /// <typeparam name="TServerResponse">The type returned from the server</typeparam>
-    public abstract class Query<TResponse> : Query
+    /// <typeparam name="THandlerResponse">The type to be returned to the caller</typeparam>
+    public abstract class Query<TServerResponse, THandlerResponse> : Query
     {
         /// <inheritdoc />
-        public override Type? GetMessageType(IMessageAccessor message) => typeof(TResponse);
+        public override Type? GetMessageType(IMessageAccessor message) => typeof(TServerResponse);
 
         /// <summary>
         /// The typed call result
         /// </summary>
-        public CallResult<TResponse>? TypedResult => (CallResult<TResponse>?)Result;
+        public CallResult<THandlerResponse>? TypedResult => (CallResult<THandlerResponse>?)Result;
 
         /// <summary>
         /// ctor
@@ -172,7 +173,7 @@ namespace CryptoExchange.Net.Sockets
         {
             Completed = true;
             Response = message.Data;
-            Result = HandleMessage(connection, message.As((TResponse)message.Data));
+            Result = HandleMessage(connection, message.As((TServerResponse)message.Data));
             _event.Set();
             ContinueAwaiter?.WaitOne();
             return Result;
@@ -184,7 +185,7 @@ namespace CryptoExchange.Net.Sockets
         /// <param name="connection"></param>
         /// <param name="message"></param>
         /// <returns></returns>
-        public virtual CallResult<TResponse> HandleMessage(SocketConnection connection, DataEvent<TResponse> message) => new CallResult<TResponse>(message.Data, message.OriginalData, null);
+        public abstract CallResult<THandlerResponse> HandleMessage(SocketConnection connection, DataEvent<TServerResponse> message);
 
         /// <inheritdoc />
         public override void Timeout()
@@ -193,7 +194,7 @@ namespace CryptoExchange.Net.Sockets
                 return;
 
             Completed = true;
-            Result = new CallResult<TResponse>(new CancellationRequestedError(null, "Query timeout", null));
+            Result = new CallResult<THandlerResponse>(new CancellationRequestedError(null, "Query timeout", null));
             ContinueAwaiter?.Set();
             _event.Set();
         }
@@ -201,10 +202,35 @@ namespace CryptoExchange.Net.Sockets
         /// <inheritdoc />
         public override void Fail(Error error)
         {
-            Result = new CallResult<TResponse>(error);
+            Result = new CallResult<THandlerResponse>(error);
             Completed = true;
             ContinueAwaiter?.Set();
             _event.Set();
         }
     }
+
+    /// <summary>
+    /// Query
+    /// </summary>
+    /// <typeparam name="TResponse">Response object type</typeparam>
+    public abstract class Query<TResponse> : Query<TResponse, TResponse>
+    {
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="authenticated"></param>
+        /// <param name="weight"></param>
+        protected Query(object request, bool authenticated, int weight = 1) : base(request, authenticated, weight)
+        {
+        }
+
+        /// <summary>
+        /// Handle the query response
+        /// </summary>
+        /// <param name="connection"></param>
+        /// <param name="message"></param>
+        /// <returns></returns>
+        public override CallResult<TResponse> HandleMessage(SocketConnection connection, DataEvent<TResponse> message) => message.ToCallResult();
+    }
 }

CryptoExchange.Net/Sockets/SocketConnection.cs

@@ -19,6 +19,28 @@ namespace CryptoExchange.Net.Sockets
     /// </summary>
     public class SocketConnection
     {
+        /// <summary>
+        /// State of a the connection
+        /// </summary>
+        /// <param name="Id">The id of the socket connection</param>
+        /// <param name="Address">The connection URI</param>
+        /// <param name="Subscriptions">Number of subscriptions on this socket</param>
+        /// <param name="Status">Socket status</param>
+        /// <param name="Authenticated">If the connection is authenticated</param>
+        /// <param name="DownloadSpeed">Download speed over this socket</param>
+        /// <param name="PendingQueries">Number of non-completed queries</param>
+        /// <param name="SubscriptionStates">State for each subscription on this socket</param>
+        public record SocketConnectionState(
+            int Id,
+            string Address,
+            int Subscriptions,
+            SocketStatus Status,
+            bool Authenticated,
+            double DownloadSpeed,
+            int PendingQueries,
+            List<Subscription.SubscriptionState> SubscriptionStates
+        );
+
         /// <summary>
         /// Connection lost event
         /// </summary>
@@ -194,6 +216,7 @@ namespace CryptoExchange.Net.Sockets
             _socket = socket;
             _socket.OnStreamMessage += HandleStreamMessage;
             _socket.OnRequestSent += HandleRequestSentAsync;
+            _socket.OnRequestRateLimited += HandleRequestRateLimitedAsync;
             _socket.OnOpen += HandleOpenAsync;
             _socket.OnClose += HandleCloseAsync;
             _socket.OnReconnecting += HandleReconnectingAsync;
@@ -228,7 +251,7 @@ namespace CryptoExchange.Net.Sockets
 
             lock (_listenersLock)
             {
-                foreach (var subscription in _listeners.OfType<Subscription>())
+                foreach (var subscription in _listeners.OfType<Subscription>().Where(l => l.UserSubscription))
                     subscription.Confirmed = false;
 
                 foreach (var query in _listeners.OfType<Query>().ToList())
@@ -253,7 +276,7 @@ namespace CryptoExchange.Net.Sockets
 
             lock (_listenersLock)
             {
-                foreach (var subscription in _listeners.OfType<Subscription>())
+                foreach (var subscription in _listeners.OfType<Subscription>().Where(l => l.UserSubscription))
                     subscription.Confirmed = false;
 
                 foreach (var query in _listeners.OfType<Query>().ToList())
@@ -337,6 +360,26 @@ namespace CryptoExchange.Net.Sockets
             return Task.CompletedTask;
         }
 
+        /// <summary>
+        /// Handler for whenever a request is rate limited and rate limit behaviour is set to fail
+        /// </summary>
+        /// <param name="requestId"></param>
+        /// <returns></returns>
+        protected virtual Task HandleRequestRateLimitedAsync(int requestId)
+        {
+            Query query;
+            lock (_listenersLock)
+            {
+                query = _listeners.OfType<Query>().FirstOrDefault(x => x.Id == requestId);
+            }
+
+            if (query == null)
+                return Task.CompletedTask;
+
+            query.Fail(new ClientRateLimitError("Connection rate limit reached"));
+            return Task.CompletedTask;
+        }
+
         /// <summary>
         /// Handler for whenever a request is sent over the websocket
         /// </summary>
@@ -455,7 +498,7 @@ namespace CryptoExchange.Net.Sockets
                     try
                     {
                         var innerSw = Stopwatch.StartNew();
-                        processor.Handle(this, new DataEvent<object>(deserialized, null, originalData, receiveTime, null));
+                        processor.Handle(this, new DataEvent<object>(deserialized, null, null, originalData, receiveTime, null));
                         totalUserTime += (int)innerSw.ElapsedMilliseconds;
                     }
                     catch (Exception ex)
@@ -478,7 +521,7 @@ namespace CryptoExchange.Net.Sockets
         /// Connect the websocket
         /// </summary>
         /// <returns></returns>
-        public async Task<bool> ConnectAsync() => await _socket.ConnectAsync().ConfigureAwait(false);
+        public async Task<CallResult> ConnectAsync() => await _socket.ConnectAsync().ConfigureAwait(false);
 
         /// <summary>
         /// Retrieve the underlying socket
@@ -620,6 +663,24 @@ namespace CryptoExchange.Net.Sockets
                 return _listeners.OfType<Subscription>().SingleOrDefault(s => s.Id == id);
         }
 
+        /// <summary>
+        /// Get the state of the connection
+        /// </summary>
+        /// <returns></returns>
+        public SocketConnectionState GetState(bool includeSubDetails)
+        {
+            return new SocketConnectionState(
+                SocketId,
+                ConnectionUri.AbsoluteUri,
+                UserSubscriptionCount,
+                Status,
+                Authenticated,
+                IncomingKbps,
+                PendingQueries: _listeners.OfType<Query>().Count(x => !x.Completed),
+                includeSubDetails ? Subscriptions.Select(sub => sub.GetState()).ToList() : new List<Subscription.SubscriptionState>()
+            );
+        }
+
         /// <summary>
         /// Send a query request and wait for an answer
         /// </summary>
@@ -635,14 +696,15 @@ namespace CryptoExchange.Net.Sockets
         /// <summary>
         /// Send a query request and wait for an answer
         /// </summary>
-        /// <typeparam name="T">Query response type</typeparam>
+        /// <typeparam name="THandlerResponse">Expected result type</typeparam>
+        /// <typeparam name="TServerResponse">The type returned to the caller</typeparam>
         /// <param name="query">Query to send</param>
         /// <param name="continueEvent">Wait event for when the socket message handler can continue</param>
         /// <returns></returns>
-        public virtual async Task<CallResult<T>> SendAndWaitQueryAsync<T>(Query<T> query, ManualResetEvent? continueEvent = null)
+        public virtual async Task<CallResult<THandlerResponse>> SendAndWaitQueryAsync<TServerResponse, THandlerResponse>(Query<TServerResponse, THandlerResponse> query, ManualResetEvent? continueEvent = null)
         {
             await SendAndWaitIntAsync(query, continueEvent).ConfigureAwait(false);
-            return query.TypedResult ?? new CallResult<T>(new ServerError("Timeout"));
+            return query.TypedResult ?? new CallResult<THandlerResponse>(new ServerError("Timeout"));
         }
 
         private async Task SendAndWaitIntAsync(Query query, ManualResetEvent? continueEvent)
@@ -710,10 +772,16 @@ namespace CryptoExchange.Net.Sockets
             if (ApiClient.MessageSendSizeLimit != null && data.Length > ApiClient.MessageSendSizeLimit.Value)
             {
                 var info = $"Message to send exceeds the max server message size ({ApiClient.MessageSendSizeLimit.Value} bytes). Split the request into batches to keep below this limit";
-                _logger.LogWarning("[Sckt {SocketId}] msg {RequestId} - {Info}", SocketId, requestId, info);
+                _logger.LogWarning("[Sckt {SocketId}] [Req {RequestId}] {Info}", SocketId, requestId, info);
                 return new CallResult(new InvalidOperationError(info));
             }
 
+            if (!_socket.IsOpen)
+            {
+                _logger.LogWarning("[Sckt {SocketId}] [Req {RequestId}] failed to send, socket no longer open", SocketId, requestId);
+                return new CallResult(new WebError("Failed to send message, socket no longer open"));
+            }
+
             _logger.SendingData(SocketId, requestId, data);
             try
             {
@@ -729,7 +797,7 @@ namespace CryptoExchange.Net.Sockets
         private async Task<CallResult> ProcessReconnectAsync()
         {
             if (!_socket.IsOpen)
-                return new CallResult<bool>(new WebError("Socket not connected"));
+                return new CallResult(new WebError("Socket not connected"));
 
             bool anySubscriptions;
             lock (_listenersLock)
@@ -739,7 +807,7 @@ namespace CryptoExchange.Net.Sockets
                 // No need to resubscribe anything
                 _logger.NothingToResubscribeCloseConnection(SocketId);
                 _ = _socket.CloseAsync();
-                return new CallResult<bool>(true);
+                return new CallResult(null);
             }
 
             bool anyAuthenticated;
@@ -779,7 +847,7 @@ namespace CryptoExchange.Net.Sockets
             for (var i = 0; i < subList.Count; i += ApiClient.ClientOptions.MaxConcurrentResubscriptionsPerSocket)
             {
                 if (!_socket.IsOpen)
-                    return new CallResult<bool>(new WebError("Socket not connected"));
+                    return new CallResult(new WebError("Socket not connected"));
 
                 var taskList = new List<Task<CallResult>>();
                 foreach (var subscription in subList.Skip(i).Take(ApiClient.ClientOptions.MaxConcurrentResubscriptionsPerSocket))
@@ -806,10 +874,10 @@ namespace CryptoExchange.Net.Sockets
                 subscription.Confirmed = true;
 
             if (!_socket.IsOpen)
-                return new CallResult<bool>(new WebError("Socket not connected"));
+                return new CallResult(new WebError("Socket not connected"));
 
             _logger.AllSubscriptionResubscribed(SocketId);
-            return new CallResult<bool>(true);
+            return new CallResult(null);
         }
 
         internal async Task UnsubscribeAsync(Subscription subscription)

CryptoExchange.Net/Sockets/Subscription.cs

@@ -5,7 +5,6 @@ using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace CryptoExchange.Net.Sockets
 {
@@ -156,6 +155,29 @@ namespace CryptoExchange.Net.Sockets
         {
             Exception?.Invoke(e);
         }
+
+        /// <summary>
+        /// State of this subscription
+        /// </summary>
+        /// <param name="Id">The id of the subscription</param>
+        /// <param name="Confirmed">True when the subscription query is handled (either accepted or rejected)</param>
+        /// <param name="Invocations">Number of times this subscription got a message</param>
+        /// <param name="Identifiers">Identifiers the subscription is listening to</param>
+        public record SubscriptionState(
+            int Id,
+            bool Confirmed,
+            int Invocations,
+            HashSet<string> Identifiers
+        );
+
+        /// <summary>
+        /// Get the state of this subscription
+        /// </summary>
+        /// <returns></returns>
+        public SubscriptionState GetState()
+        {
+            return new SubscriptionState(Id, Confirmed, TotalInvocations, ListenerIdentifiers);
+        }
     }
 
     /// <inheritdoc />

CryptoExchange.Net/Sockets/SystemSubscription.cs

@@ -3,7 +3,6 @@ using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Sockets;
 using Microsoft.Extensions.Logging;
 using System;
-using System.Threading.Tasks;
 
 namespace CryptoExchange.Net.Sockets
 {

CryptoExchange.Net/Testing/Comparers/JsonNetComparer.cs

@@ -0,0 +1,375 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using System.Text.Json.Nodes;
+using CryptoExchange.Net.Converters;
+using CryptoExchange.Net.Converters.JsonNet;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace CryptoExchange.Net.Testing.Comparers
+{
+    internal class JsonNetComparer
+    {
+        internal static void CompareData(
+            string method,
+            object resultData,
+            string json,
+            string? nestedJsonProperty,
+            List<string>? ignoreProperties = null,
+            bool userSingleArrayItem = false)
+        {
+            var resultProperties = resultData.GetType().GetProperties().Select(p => (p, (JsonPropertyAttribute?)p.GetCustomAttributes(typeof(JsonPropertyAttribute), true).SingleOrDefault()));
+            var jsonObject = JToken.Parse(json);
+            if (nestedJsonProperty != null)
+            {
+                var nested = nestedJsonProperty.Split('.');
+                foreach (var nest in nested)
+                    jsonObject = jsonObject![nest];
+            }
+
+            if (userSingleArrayItem)
+                jsonObject = ((JArray)jsonObject!)[0];
+
+            if (resultData.GetType().GetInterfaces().Contains(typeof(IDictionary)))
+            {
+                var dict = (IDictionary)resultData;
+                var jObj = (JObject)jsonObject!;
+                var properties = jObj.Properties();
+                foreach (var dictProp in properties)
+                {
+                    if (!dict.Contains(dictProp.Name))
+                        throw new Exception($"{method}: Dictionary has no value for {dictProp.Name} while input json `{dictProp.Name}` has value {dictProp.Value}");
+
+                    if (dictProp.Value.Type == JTokenType.Object)
+                    {
+                        // TODO Some additional checking for objects
+                        foreach (var prop in ((JObject)dictProp.Value).Properties())
+                            CheckObject(method, prop, dict[dictProp.Name]!, ignoreProperties!);
+                    }
+                    else
+                    {
+                        if (dict[dictProp.Name] == default && dictProp.Value.Type != JTokenType.Null)
+                            // Property value not correct
+                            throw new Exception($"{method}: Dictionary entry `{dictProp.Name}` has no value while input json has value {dictProp.Value}");
+                    }
+                }
+            }
+            else if (jsonObject!.Type == JTokenType.Array)
+            {
+                var jObjs = (JArray)jsonObject;
+                if (resultData is IEnumerable list)
+                {
+                    var enumerator = list.GetEnumerator();
+                    foreach (var jObj in jObjs)
+                    {
+                        enumerator.MoveNext();
+                        if (jObj.Type == JTokenType.Object)
+                        {
+                            foreach (var subProp in ((JObject)jObj).Properties())
+                            {
+                                if (ignoreProperties?.Contains(subProp.Name) == true)
+                                    continue;
+                                CheckObject(method, subProp, enumerator.Current, ignoreProperties!);
+                            }
+                        }
+                        else if (jObj.Type == JTokenType.Array)
+                        {
+                            var resultObj = enumerator.Current;
+                            var resultProps = resultObj.GetType().GetProperties().Select(p => (p, p.GetCustomAttributes(typeof(ArrayPropertyAttribute), true).Cast<ArrayPropertyAttribute>().SingleOrDefault()));
+                            var arrayConverterProperty = resultObj.GetType().GetCustomAttributes(typeof(JsonConverterAttribute), true).FirstOrDefault();
+                            var jsonConverter = ((JsonConverterAttribute)arrayConverterProperty!).ConverterType;
+                            if (jsonConverter != typeof(ArrayConverter))
+                                // Not array converter?
+                                continue;
+
+                            int i = 0;
+                            foreach (var item in jObj.Values())
+                            {
+                                var arrayProp = resultProps.SingleOrDefault(p => p.Item2!.Index == i).p;
+                                if (arrayProp != null)
+                                    CheckPropertyValue(method, item, arrayProp.GetValue(resultObj), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties!);
+                                i++;
+                            }
+                        }
+                        else
+                        {
+                            var value = enumerator.Current;
+                            if (value == default && ((JValue)jObj).Type != JTokenType.Null)
+                                throw new Exception($"{method}: Array has no value while input json array has value {jObj}");
+                        }
+                    }
+                }
+                else
+                {
+                    var resultProps = resultData.GetType().GetProperties().Select(p => (p, p.GetCustomAttributes(typeof(ArrayPropertyAttribute), true).Cast<ArrayPropertyAttribute>().SingleOrDefault()));
+                    int i = 0;
+                    foreach (var item in jObjs.Values())
+                    {
+                        var arrayProp = resultProps.SingleOrDefault(p => p.Item2!.Index == i).p;
+                        if (arrayProp != null)
+                            CheckPropertyValue(method, item, arrayProp.GetValue(resultData), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties!);
+                        i++;
+                    }
+                }
+            }
+            else
+            {
+                foreach (var item in jsonObject)
+                {
+                    if (item is JProperty prop)
+                    {
+                        if (ignoreProperties?.Contains(prop.Name) == true)
+                            continue;
+
+                        CheckObject(method, prop, resultData, ignoreProperties);
+                    }
+                }
+            }
+
+            Debug.WriteLine($"Successfully validated {method}");
+        }
+
+        private static void CheckObject(string method, JProperty prop, object obj, List<string>? ignoreProperties)
+        {
+            var resultProperties = obj.GetType().GetProperties().Select(p => (p, ((JsonPropertyAttribute?)p.GetCustomAttributes(typeof(JsonPropertyAttribute), true).SingleOrDefault())?.PropertyName));
+
+            // Property has a value
+            var property = resultProperties.SingleOrDefault(p => p.PropertyName == prop.Name).p;
+            property ??= resultProperties.SingleOrDefault(p => p.p.Name == prop.Name).p;
+            property ??= resultProperties.SingleOrDefault(p => p.p.Name.Equals(prop.Name, StringComparison.InvariantCultureIgnoreCase)).p;
+
+            if (property is null)
+                // Property not found
+                throw new Exception($"{method}: Missing property `{prop.Name}` on `{obj.GetType().Name}`");
+
+            var propertyValue = property.GetValue(obj);
+            if (property.GetCustomAttribute<JsonPropertyAttribute>(true)?.ItemConverterType == null)
+                CheckPropertyValue(method, prop.Value, propertyValue, property.PropertyType, property.Name, prop.Name, ignoreProperties);
+        }
+
+        private static void CheckPropertyValue(string method, JToken propValue, object? propertyValue, Type propertyType, string? propertyName = null, string? propName = null, List<string>? ignoreProperties = null)
+        {
+            if (propertyValue == default && propValue.Type != JTokenType.Null && !string.IsNullOrEmpty(propValue.ToString()))
+            {
+                if (propertyType == typeof(DateTime?) && (propValue.ToString() == "" || propValue.ToString() == "0" || propValue.ToString() == "-1"))
+                    return;
+
+                // Property value not correct
+                if (propValue.ToString() != "0")
+                    throw new Exception($"{method}: Property `{propertyName}` has no value while input json `{propName}` has value {propValue}");
+            }
+
+            if (propertyValue == default && (propValue.Type == JTokenType.Null || string.IsNullOrEmpty(propValue.ToString())) || propValue.ToString() == "0")
+                return;
+
+            if (propertyValue!.GetType().GetInterfaces().Contains(typeof(IDictionary)))
+            {
+                var dict = (IDictionary)propertyValue;
+                var jObj = (JObject)propValue;
+                var properties = jObj.Properties();
+                foreach (var dictProp in properties)
+                {
+                    if (!dict.Contains(dictProp.Name))
+                        throw new Exception($"{method}: Property `{propertyName}` has no value while input json `{propName}` has value {propValue}");
+
+                    if (dictProp.Value.Type == JTokenType.Object)
+                    {
+                        CheckObject(method, dictProp, dict[dictProp.Name]!, ignoreProperties);
+                    }
+                    else
+                    {
+                        if (dict[dictProp.Name] == default && dictProp.Value.Type != JTokenType.Null)
+                            // Property value not correct
+                            throw new Exception($"{method}: Dictionary entry `{dictProp.Name}` has no value while input json has value {propValue} for");
+                    }
+                }
+            }
+            else if (propertyValue.GetType().GetInterfaces().Contains(typeof(IEnumerable))
+                && propertyValue.GetType() != typeof(string))
+            {
+                var jObjs = (JArray)propValue;
+                var list = (IEnumerable)propertyValue;
+                var enumerator = list.GetEnumerator();
+                foreach (JToken jtoken in jObjs)
+                {
+                    enumerator.MoveNext();
+                    var typeConverter = enumerator.Current.GetType().GetCustomAttributes(typeof(JsonConverterAttribute), true);
+                    if (typeConverter.Length != 0 && ((JsonConverterAttribute)typeConverter.First()).ConverterType != typeof(ArrayConverter))
+                        // Custom converter for the type, skip
+                        continue;
+
+                    if (jtoken.Type == JTokenType.Object)
+                    {
+                        foreach (var subProp in ((JObject)jtoken).Properties())
+                        {
+                            if (ignoreProperties?.Contains(subProp.Name) == true)
+                                continue;
+
+                            CheckObject(method, subProp, enumerator.Current, ignoreProperties);
+                        }
+                    }
+                    else if (jtoken.Type == JTokenType.Array)
+                    {
+                        var resultObj = enumerator.Current;
+                        var resultProps = resultObj.GetType().GetProperties().Select(p => (p, p.GetCustomAttributes(typeof(ArrayPropertyAttribute), true).Cast<ArrayPropertyAttribute>().SingleOrDefault()));
+                        var arrayConverterProperty = resultObj.GetType().GetCustomAttributes(typeof(JsonConverterAttribute), true).FirstOrDefault();
+                        var jsonConverter = ((JsonConverterAttribute)arrayConverterProperty!).ConverterType;
+                        if (jsonConverter != typeof(ArrayConverter))
+                            // Not array converter?
+                            continue;
+
+                        int i = 0;
+                        foreach (var item in jtoken.Values())
+                        {
+                            var arrayProp = resultProps.SingleOrDefault(p => p.Item2!.Index == i).p;
+                            if (arrayProp != null)
+                                CheckPropertyValue(method, item, arrayProp.GetValue(resultObj), propertyType, arrayProp.Name, "Array index " + i, ignoreProperties);
+
+                            i++;
+                        }
+                    }
+                    else
+                    {
+                        var value = enumerator.Current;
+                        if (value == default && ((JValue)jtoken).Type != JTokenType.Null)
+                            throw new Exception($"{method}: Property `{propertyName}` has no value while input json `{propName}` has value {jtoken}");
+
+                        CheckValues(method, propertyName!, propertyType, (JValue)jtoken, value!);
+                    }
+                }
+            }
+            else
+            {
+                if (propValue.Type == JTokenType.Object)
+                {
+                    foreach (var item in propValue)
+                    {
+                        if (item is JProperty prop)
+                        {
+                            if (ignoreProperties?.Contains(prop.Name) == true)
+                                continue;
+
+                            CheckObject(method, prop, propertyValue, ignoreProperties);
+                        }
+                    }
+                }
+                else if(propValue.Type == JTokenType.Array)
+                {
+                    var jObjs = (JArray)propValue;
+                    if (propertyValue is IEnumerable list)
+                    {
+                        var enumerator = list.GetEnumerator();
+                        foreach (var jObj in jObjs)
+                        {
+                            enumerator.MoveNext();
+                            if (jObj.Type == JTokenType.Object)
+                            {
+                                foreach (var subProp in ((JObject)jObj).Properties())
+                                {
+                                    if (ignoreProperties?.Contains(subProp.Name) == true)
+                                        continue;
+                                    CheckObject(method, subProp, enumerator.Current, ignoreProperties!);
+                                }
+                            }
+                            else if (jObj.Type == JTokenType.Array)
+                            {
+                                var resultObj = enumerator.Current;
+                                var resultProps = resultObj.GetType().GetProperties().Select(p => (p, p.GetCustomAttributes(typeof(ArrayPropertyAttribute), true).Cast<ArrayPropertyAttribute>().SingleOrDefault()));
+                                var arrayConverterProperty = resultObj.GetType().GetCustomAttributes(typeof(JsonConverterAttribute), true).FirstOrDefault();
+                                var jsonConverter = ((JsonConverterAttribute)arrayConverterProperty!).ConverterType;
+                                if (jsonConverter != typeof(ArrayConverter))
+                                    // Not array converter?
+                                    continue;
+
+                                int i = 0;
+                                foreach (var item in jObj.Values())
+                                {
+                                    var arrayProp = resultProps.SingleOrDefault(p => p.Item2!.Index == i).p;
+                                    if (arrayProp != null)
+                                        CheckPropertyValue(method, item, arrayProp.GetValue(resultObj), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties!);
+                                    i++;
+                                }
+                            }
+                            else
+                            {
+                                var value = enumerator.Current;
+                                if (value == default && ((JValue)jObj).Type != JTokenType.Null)
+                                    throw new Exception($"{method}: Array has no value while input json array has value {jObj}");
+                            }
+                        }
+                    }
+                    else
+                    {
+                        var resultProps = propertyValue.GetType().GetProperties().Select(p => (p, p.GetCustomAttributes(typeof(ArrayPropertyAttribute), true).Cast<ArrayPropertyAttribute>().SingleOrDefault()));
+                        int i = 0;
+                        foreach (var item in jObjs.Values())
+                        {
+                            var arrayProp = resultProps.SingleOrDefault(p => p.Item2!.Index == i).p;
+                            if (arrayProp != null)
+                                CheckPropertyValue(method, item, arrayProp.GetValue(propertyValue), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties!);
+                            i++;
+                        }
+                    }
+                }
+                else
+                {
+                    CheckValues(method, propertyName!, propertyType, (JValue)propValue, propertyValue);
+                }
+            }
+        }
+
+        private static void CheckValues(string method, string property, Type propertyType, JValue jsonValue, object objectValue)
+        {
+            if (jsonValue.Type == JTokenType.String)
+            {
+                if (objectValue is decimal dec)
+                {
+                    if (jsonValue.Value<decimal>() != dec)
+                        throw new Exception($"{method}: {property} not equal: {jsonValue.Value<decimal>()} vs {dec}");
+                }
+                else if (objectValue is DateTime time)
+                {
+                    if (time != DateTimeConverter.ParseFromString(jsonValue.Value<string>()!))
+                        throw new Exception($"{method}: {property} not equal: {jsonValue.Value<decimal>()} vs {time}");
+                }
+                else if (propertyType.IsEnum || Nullable.GetUnderlyingType(propertyType)?.IsEnum == true)
+                {
+                    // TODO enum comparing
+                }
+                else if (!jsonValue.Value<string>()!.Equals(Convert.ToString(objectValue, CultureInfo.InvariantCulture), StringComparison.InvariantCultureIgnoreCase))
+                {
+                    throw new Exception($"{method}: {property} not equal: {jsonValue.Value<string>()} vs {objectValue}");
+                }
+            }
+            else if (jsonValue.Type == JTokenType.Integer)
+            {
+                if (objectValue is DateTime time)
+                {
+                    if (time != DateTimeConverter.ParseFromLong(jsonValue.Value<long>()!))
+                        throw new Exception($"{method}: {property} not equal: {jsonValue.Value<decimal>()} vs {time}");
+                }
+                else if (propertyType.IsEnum)
+                {
+                    // TODO enum comparing
+                }
+                else if (jsonValue.Value<long>() != Convert.ToInt64(objectValue))
+                {
+                    throw new Exception($"{method}: {property} not equal: {jsonValue.Value<long>()} vs {Convert.ToInt64(objectValue)}");
+                }
+            }
+            else if (jsonValue.Type == JTokenType.Boolean)
+            {
+                if (objectValue is bool boolVal && jsonValue.Value<bool>() != boolVal)
+                    throw new Exception($"{method}: {property} not equal: {jsonValue.Value<bool>()} vs {(bool)objectValue}");
+
+                if (jsonValue.Value<bool>() != bool.Parse(objectValue.ToString()))
+                    throw new Exception($"{method}: {property} not equal: {jsonValue.Value<bool>()} vs {(bool)objectValue}");
+            }
+        }
+    }
+}

CryptoExchange.Net/Testing/Comparers/SystemTextJsonComparer.cs

@@ -0,0 +1,305 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.Linq;
+using System.Text.Json.Serialization;
+using CryptoExchange.Net.Converters;
+using CryptoExchange.Net.Converters.SystemTextJson;
+using Newtonsoft.Json.Linq;
+
+namespace CryptoExchange.Net.Testing.Comparers
+{
+    internal class SystemTextJsonComparer
+    {
+        internal static void CompareData(
+            string method,
+            object resultData,
+            string json,
+            string? nestedJsonProperty,
+            List<string>? ignoreProperties = null,
+            bool userSingleArrayItem = false)
+        {
+            var resultProperties = resultData.GetType().GetProperties().Select(p => (p, (JsonPropertyNameAttribute?)p.GetCustomAttributes(typeof(JsonPropertyNameAttribute), true).SingleOrDefault()));
+            var jsonObject = JToken.Parse(json);
+            if (nestedJsonProperty != null)
+            {
+                var nested = nestedJsonProperty.Split('.');
+                foreach(var nest in nested)
+                    jsonObject = jsonObject![nest];
+            }
+
+            if (userSingleArrayItem)
+                jsonObject = ((JArray)jsonObject!)[0];
+
+            if (resultData.GetType().GetInterfaces().Contains(typeof(IDictionary)))
+            {
+                var dict = (IDictionary)resultData;
+                var jObj = (JObject)jsonObject!;
+                var properties = jObj.Properties();
+                foreach (var dictProp in properties)
+                {
+                    if (!dict.Contains(dictProp.Name))
+                        throw new Exception($"{method}: Dictionary has no value for {dictProp.Name} while input json `{dictProp.Name}` has value {dictProp.Value}");
+
+                    if (dictProp.Value.Type == JTokenType.Object)
+                    {
+                        // TODO Some additional checking for objects
+                        foreach (var prop in ((JObject)dictProp.Value).Properties())
+                            CheckObject(method, prop, dict[dictProp.Name]!, ignoreProperties!);
+                    }
+                    else
+                    {
+                        if (dict[dictProp.Name] == default && dictProp.Value.Type != JTokenType.Null)
+                        {
+                            if (dictProp.Value.ToString() == "")
+                                continue;
+
+                            // Property value not correct
+                            throw new Exception($"{method}: Dictionary entry `{dictProp.Name}` has no value while input json has value {dictProp.Value}");
+                        }
+                    }
+                }
+            }
+            else if (jsonObject!.Type == JTokenType.Array)
+            {
+                var jObjs = (JArray)jsonObject;
+                var list = (IEnumerable)resultData;
+                var enumerator = list.GetEnumerator();
+                foreach (var jObj in jObjs)
+                {
+                    enumerator.MoveNext();
+                    if (jObj.Type == JTokenType.Object)
+                    {
+                        foreach (var subProp in ((JObject)jObj).Properties())
+                        {
+                            if (ignoreProperties?.Contains(subProp.Name) == true)
+                                continue;
+                            CheckObject(method, subProp, enumerator.Current, ignoreProperties!);
+                        }
+                    }
+                    else if (jObj.Type == JTokenType.Array)
+                    {
+                        var resultObj = enumerator.Current;
+                        var resultProps = resultObj.GetType().GetProperties().Select(p => (p, p.GetCustomAttributes(typeof(ArrayPropertyAttribute), true).Cast<ArrayPropertyAttribute>().SingleOrDefault()));
+                        var arrayConverterProperty = resultObj.GetType().GetCustomAttributes(typeof(JsonConverterAttribute), true).FirstOrDefault();
+                        var jsonConverter = ((JsonConverterAttribute)arrayConverterProperty!).ConverterType;
+                        if (jsonConverter != typeof(ArrayConverter))
+                            // Not array converter?
+                            continue;
+
+                        int i = 0;
+                        foreach (var item in jObj.Values())
+                        {
+                            var arrayProp = resultProps.SingleOrDefault(p => p.Item2!.Index == i).p;
+                            if (arrayProp != null)
+                                CheckPropertyValue(method, item, arrayProp.GetValue(resultObj), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties!);
+                            i++;
+                        }
+                    }
+                    else
+                    {
+                        var value = enumerator.Current;
+                        if (value == default && ((JValue)jObj).Type != JTokenType.Null)
+                            throw new Exception($"{method}: Array has no value while input json array has value {jObj}");
+                    }
+                }
+            }
+            else
+            {
+                foreach (var item in jsonObject)
+                {
+                    if (item is JProperty prop)
+                    {
+                        if (ignoreProperties?.Contains(prop.Name) == true)
+                            continue;
+
+                        CheckObject(method, prop, resultData, ignoreProperties);
+                    }
+                }
+            }
+
+            Debug.WriteLine($"Successfully validated {method}");
+        }
+
+        private static void CheckObject(string method, JProperty prop, object obj, List<string>? ignoreProperties)
+        {
+            var resultProperties = obj.GetType().GetProperties().Select(p => (p, ((JsonPropertyNameAttribute?)p.GetCustomAttributes(typeof(JsonPropertyNameAttribute), true).SingleOrDefault())?.Name));
+
+            // Property has a value
+            var property = resultProperties.SingleOrDefault(p => p.Name == prop.Name).p;
+            property ??= resultProperties.SingleOrDefault(p => p.p.Name == prop.Name).p;
+            property ??= resultProperties.SingleOrDefault(p => p.p.Name.Equals(prop.Name, StringComparison.InvariantCultureIgnoreCase)).p;
+
+            if (property is null)
+                // Property not found
+                throw new Exception($"{method}: Missing property `{prop.Name}` on `{obj.GetType().Name}`");
+
+            var propertyValue = property.GetValue(obj);
+            CheckPropertyValue(method, prop.Value, propertyValue, property.PropertyType, property.Name, prop.Name, ignoreProperties);
+        }
+
+        private static void CheckPropertyValue(string method, JToken propValue, object? propertyValue, Type propertyType, string? propertyName = null, string? propName = null, List<string>? ignoreProperties = null)
+        {
+            if (propertyValue == default && propValue.Type != JTokenType.Null && !string.IsNullOrEmpty(propValue.ToString()))
+            {
+                if (propertyType == typeof(DateTime?) && (propValue.ToString() == "" || propValue.ToString() == "0" || propValue.ToString() == "-1"))
+                    return;
+
+                // Property value not correct
+                if (propValue.ToString() != "0")
+                    throw new Exception($"{method}: Property `{propertyName}` has no value while input json `{propName}` has value {propValue}");
+            }
+
+            if (propertyValue == default && (propValue.Type == JTokenType.Null || string.IsNullOrEmpty(propValue.ToString())) || propValue.ToString() == "0")
+                return;
+
+            if (propertyValue!.GetType().GetInterfaces().Contains(typeof(IDictionary)))
+            {
+                var dict = (IDictionary)propertyValue;
+                var jObj = (JObject)propValue;
+                var properties = jObj.Properties();
+                foreach (var dictProp in properties)
+                {
+                    if (!dict.Contains(dictProp.Name))
+                        throw new Exception($"{method}: Property `{propertyName}` has no value while input json `{propName}` has value {propValue}");
+
+                    if (dictProp.Value.Type == JTokenType.Object)
+                    {
+                        CheckPropertyValue(method, dictProp.Value, dict[dictProp.Name]!, dict[dictProp.Name].GetType(), null, null, ignoreProperties);
+                    }
+                    else
+                    {
+                        if (dict[dictProp.Name] == default && dictProp.Value.Type != JTokenType.Null)
+                            // Property value not correct
+                            throw new Exception($"{method}: Dictionary entry `{dictProp.Name}` has no value while input json has value {propValue} for");
+                    }
+                }
+            }
+            else if (propertyValue.GetType().GetInterfaces().Contains(typeof(IEnumerable))
+                && propertyValue.GetType() != typeof(string))
+            {
+                var jObjs = (JArray)propValue;
+                var list = (IEnumerable)propertyValue;
+                var enumerator = list.GetEnumerator();
+                foreach (JToken jtoken in jObjs)
+                {
+                    var moved = enumerator.MoveNext();
+                    if (!moved)
+                        throw new Exception("Enumeration not moved; incorrect amount of results?");
+
+                    var typeConverter = enumerator.Current.GetType().GetCustomAttributes(typeof(JsonConverterAttribute), true);
+                    if (typeConverter.Length != 0 && ((JsonConverterAttribute)typeConverter.First()).ConverterType != typeof(ArrayConverter))
+                        // Custom converter for the type, skip
+                        continue;
+
+                    if (jtoken.Type == JTokenType.Object)
+                    {
+                        foreach (var subProp in ((JObject)jtoken).Properties())
+                        {
+                            if (ignoreProperties?.Contains(subProp.Name) == true)
+                                continue;
+
+                            CheckObject(method, subProp, enumerator.Current, ignoreProperties);
+                        }
+                    }
+                    else if (jtoken.Type == JTokenType.Array)
+                    {
+                        var resultObj = enumerator.Current;
+                        var resultProps = resultObj.GetType().GetProperties().Select(p => (p, p.GetCustomAttributes(typeof(ArrayPropertyAttribute), true).Cast<ArrayPropertyAttribute>().SingleOrDefault()));
+                        var arrayConverterProperty = resultObj.GetType().GetCustomAttributes(typeof(JsonConverterAttribute), true).FirstOrDefault();
+                        var jsonConverter = ((JsonConverterAttribute)arrayConverterProperty!).ConverterType;
+                        if (jsonConverter != typeof(ArrayConverter))
+                            // Not array converter?
+                            continue;
+
+                        int i = 0;
+                        foreach (var item in jtoken.Values())
+                        {
+                            var arrayProp = resultProps.SingleOrDefault(p => p.Item2!.Index == i).p;
+                            if (arrayProp != null)
+                                CheckPropertyValue(method, item, arrayProp.GetValue(resultObj), propertyType, arrayProp.Name, "Array index " + i, ignoreProperties);
+
+                            i++;
+                        }
+                    }
+                    else
+                    {
+                        var value = enumerator.Current;
+                        if (value == default && ((JValue)jtoken).Type != JTokenType.Null)
+                            throw new Exception($"{method}: Property `{propertyName}` has no value while input json `{propName}` has value {jtoken}");
+
+                        CheckValues(method, propertyName!, propertyType, (JValue)jtoken, value!);
+                    }
+                }
+            }
+            else
+            {
+                if (propValue.Type == JTokenType.Object)
+                {
+                    foreach (var item in propValue)
+                    {
+                        if (item is JProperty prop)
+                        {
+                            if (ignoreProperties?.Contains(prop.Name) == true)
+                                continue;
+
+                            CheckObject(method, prop, propertyValue, ignoreProperties);
+                        }
+                    }
+                }
+                else
+                {
+                    CheckValues(method, propertyName!, propertyType, (JValue)propValue, propertyValue);
+                }
+            }
+        }
+
+        private static void CheckValues(string method, string property, Type propertyType, JValue jsonValue, object objectValue)
+        {
+            if (jsonValue.Type == JTokenType.String)
+            {
+                if (objectValue is decimal dec)
+                {
+                    if (jsonValue.Value<decimal>() != dec)
+                        throw new Exception($"{method}: {property} not equal: {jsonValue.Value<decimal>()} vs {dec}");
+                }
+                else if (objectValue is DateTime time)
+                {
+                    if (time != DateTimeConverter.ParseFromString(jsonValue.Value<string>()!))
+                        throw new Exception($"{method}: {property} not equal: {jsonValue.Value<string>()} vs {time}");
+                }
+                else if (propertyType.IsEnum || Nullable.GetUnderlyingType(propertyType)?.IsEnum == true)
+                {
+                    // TODO enum comparing
+                }
+                else if (!jsonValue.Value<string>()!.Equals(Convert.ToString(objectValue, CultureInfo.InvariantCulture), StringComparison.InvariantCultureIgnoreCase))
+                {
+                    throw new Exception($"{method}: {property} not equal: {jsonValue.Value<string>()} vs {objectValue}");
+                }
+            }
+            else if (jsonValue.Type == JTokenType.Integer)
+            {
+                if (objectValue is DateTime time)
+                {
+                    if (time != DateTimeConverter.ParseFromDouble(jsonValue.Value<long>()!))
+                        throw new Exception($"{method}: {property} not equal: {jsonValue.Value<decimal>()} vs {time}");
+                }
+                else if (propertyType.IsEnum || Nullable.GetUnderlyingType(propertyType)?.IsEnum == true)
+                {
+                    // TODO enum comparing
+                }
+                else if (jsonValue.Value<long>() != Convert.ToInt64(objectValue))
+                {
+                    throw new Exception($"{method}: {property} not equal: {jsonValue.Value<long>()} vs {Convert.ToInt64(objectValue)}");
+                }
+            }
+            else if (jsonValue.Type == JTokenType.Boolean)
+            {
+                if (jsonValue.Value<bool>() != (bool)objectValue)
+                    throw new Exception($"{method}: {property} not equal: {jsonValue.Value<bool>()} vs {(bool)objectValue}");
+            }
+        }
+    }
+}

CryptoExchange.Net/Testing/EnumValueTraceListener.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Diagnostics;
+
+namespace CryptoExchange.Net.Testing
+{
+    internal class EnumValueTraceListener : TraceListener
+    {
+        public override void Write(string message)
+        {
+            if (message.Contains("Cannot map"))
+                throw new Exception("Enum value error: " + message);
+        }
+
+        public override void WriteLine(string message)
+        {
+            if (message.Contains("Cannot map"))
+                throw new Exception("Enum value error: " + message);
+        }
+    }
+}

CryptoExchange.Net/Testing/Implementations/TestAuthTimeProvider.cs

@@ -0,0 +1,17 @@
+using CryptoExchange.Net.Interfaces;
+using System;
+
+namespace CryptoExchange.Net.Testing.Implementations
+{
+    internal class TestAuthTimeProvider : IAuthTimeProvider
+    {
+        private readonly DateTime _timestamp;
+
+        public TestAuthTimeProvider(DateTime timestamp)
+        {
+            _timestamp = timestamp;
+        }
+
+        public DateTime GetTime() => _timestamp;
+    }
+}

CryptoExchange.Net/Testing/Implementations/TestNonceProvider.cs

@@ -0,0 +1,23 @@
+using CryptoExchange.Net.Interfaces;
+
+namespace CryptoExchange.Net.Testing.Implementations
+{
+    /// <summary>
+    /// Test implementation for nonce provider, returning a prespecified nonce
+    /// </summary>
+    public class TestNonceProvider : INonceProvider
+    {
+        private readonly long _nonce;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public TestNonceProvider(long nonce)
+        {
+            _nonce = nonce;
+        }
+
+        /// <inheritdoc />
+        public long GetNonce() => _nonce;
+    }
+}

CryptoExchange.Net/Testing/Implementations/TestRequest.cs

@@ -0,0 +1,52 @@
+using CryptoExchange.Net.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Testing.Implementations
+{
+    internal class TestRequest : IRequest
+    {
+        private readonly Dictionary<string, IEnumerable<string>> _headers = new Dictionary<string, IEnumerable<string>>();
+        private readonly TestResponse _response;
+
+        public string Accept { set { } }
+
+        public string? Content { get; private set; }
+
+        public HttpMethod Method { get; set; }
+
+        public Uri Uri { get; set; }
+
+        public int RequestId { get; set; }
+
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public TestRequest(TestResponse response)
+#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            _response = response;
+        }
+
+        public void AddHeader(string key, string value)
+        {
+            _headers.Add(key, new[] { value });
+        }
+
+        public Dictionary<string, IEnumerable<string>> GetHeaders() => _headers;
+
+        public Task<IResponse> GetResponseAsync(CancellationToken cancellationToken) => Task.FromResult<IResponse>(_response);
+
+        public void SetContent(byte[] data)
+        {
+            Content = Encoding.UTF8.GetString(data);
+        }
+
+        public void SetContent(string data, string contentType)
+        {
+            Content = data;
+        }
+    }
+}

CryptoExchange.Net/Testing/Implementations/TestRequestFactory.cs

@@ -0,0 +1,29 @@
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects;
+using System;
+using System.Net.Http;
+
+namespace CryptoExchange.Net.Testing.Implementations
+{
+    internal class TestRequestFactory : IRequestFactory
+    {
+        private readonly TestRequest _request;
+
+        public TestRequestFactory(TestRequest request)
+        {
+            _request = request;
+        }
+
+        public void Configure(ApiProxy? proxy, TimeSpan requestTimeout, HttpClient? httpClient = null)
+        {
+        }
+
+        public IRequest Create(HttpMethod method, Uri uri, int requestId)
+        {
+            _request.Method = method;
+            _request.Uri = uri;
+            _request.RequestId = requestId;
+            return _request;
+        }
+    }
+}

CryptoExchange.Net/Testing/Implementations/TestResponse.cs

@@ -0,0 +1,34 @@
+using CryptoExchange.Net.Interfaces;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Testing.Implementations
+{
+    internal class TestResponse : IResponse
+    {
+        private readonly Stream _response;
+
+        public HttpStatusCode StatusCode { get; }
+
+        public bool IsSuccessStatusCode { get; }
+
+        public long? ContentLength { get; }
+
+        public IEnumerable<KeyValuePair<string, IEnumerable<string>>> ResponseHeaders { get; } = new Dictionary<string, IEnumerable<string>>();
+
+        public TestResponse(HttpStatusCode code, Stream response)
+        {
+            StatusCode = code;
+            IsSuccessStatusCode = code == HttpStatusCode.OK;
+            _response = response;
+        }
+
+        public void Close()
+        {
+        }
+
+        public Task<Stream> GetResponseStreamAsync() => Task.FromResult(_response);
+    }
+}

CryptoExchange.Net/Testing/Implementations/TestSocket.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Net.WebSockets;
+using System.Text;
+using System.Threading.Tasks;
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects;
+using Newtonsoft.Json;
+
+namespace CryptoExchange.Net.Testing.Implementations
+{
+    internal class TestSocket : IWebsocket
+    {
+        public event Action<string>? OnMessageSend;
+
+        public bool CanConnect { get; set; } = true;
+        public bool Connected { get; set; }
+
+        public event Func<Task>? OnClose;
+#pragma warning disable 0067
+        public event Func<Task>? OnReconnected;
+        public event Func<Task>? OnReconnecting;
+        public event Func<int, Task>? OnRequestRateLimited;
+        public event Func<Exception, Task>? OnError;
+#pragma warning restore 0067
+        public event Func<int, Task>? OnRequestSent;
+        public event Action<WebSocketMessageType, ReadOnlyMemory<byte>>? OnStreamMessage;
+        public event Func<Task>? OnOpen;
+
+        public int Id { get; }
+        public bool IsClosed => !Connected;
+        public bool IsOpen => Connected;
+        public double IncomingKbps => 0;
+        public Uri Uri => new("wss://test.com/ws");
+        public Func<Task<Uri?>>? GetReconnectionUrl { get; set; }
+
+        public Task<CallResult> ConnectAsync()
+        {
+            Connected = CanConnect;
+            return Task.FromResult(CanConnect ? new CallResult(null) : new CallResult(new CantConnectError()));
+        }
+
+        public void Send(int requestId, string data, int weight)
+        {
+            if (!Connected)
+                throw new Exception("Socket not connected");
+
+            OnRequestSent?.Invoke(requestId);
+            OnMessageSend?.Invoke(data);
+        }
+
+        public Task CloseAsync()
+        {
+            Connected = false;
+            return Task.FromResult(0);
+        }
+
+        public void InvokeClose()
+        {
+            Connected = false;
+            OnClose?.Invoke();
+        }
+
+        public void InvokeOpen()
+        {
+            OnOpen?.Invoke();
+        }
+
+        public void InvokeMessage(string data)
+        {
+            OnStreamMessage?.Invoke(WebSocketMessageType.Text, new ReadOnlyMemory<byte>(Encoding.UTF8.GetBytes(data)));
+        }
+
+        public void InvokeMessage<T>(T data)
+        {
+            OnStreamMessage?.Invoke(WebSocketMessageType.Text, new ReadOnlyMemory<byte>(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(data))));
+        }
+
+        public Task ReconnectAsync() => throw new NotImplementedException();
+        public void Dispose() { }
+    }
+}

CryptoExchange.Net/Testing/Implementations/TestWebsocketFactory.cs

@@ -0,0 +1,17 @@
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects.Sockets;
+using Microsoft.Extensions.Logging;
+
+namespace CryptoExchange.Net.Testing.Implementations
+{
+    internal class TestWebsocketFactory : IWebsocketFactory
+    {
+        private readonly TestSocket _socket;
+        public TestWebsocketFactory(TestSocket socket)
+        {
+            _socket = socket;
+        }
+
+        public IWebsocket CreateWebsocket(ILogger logger, WebSocketParameters parameters) => _socket;
+    }
+}

CryptoExchange.Net/Testing/RestRequestValidator.cs

@@ -0,0 +1,191 @@
+using CryptoExchange.Net.Clients;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Testing.Comparers;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Testing
+{
+    /// <summary>
+    /// Validator for REST requests, comparing path, http method, authentication and response parsing
+    /// </summary>
+    /// <typeparam name="TClient">The Rest client</typeparam>
+    public class RestRequestValidator<TClient> where TClient : BaseRestClient
+    {
+        private readonly TClient _client;
+        private readonly Func<WebCallResult, bool> _isAuthenticated;
+        private readonly string _folder;
+        private readonly string _baseAddress;
+        private readonly string? _nestedPropertyForCompare;
+        private readonly bool _stjCompare;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="client">Client to test</param>
+        /// <param name="folder">Folder for json test values</param>
+        /// <param name="baseAddress">The base address that is expected</param>
+        /// <param name="isAuthenticated">Func for checking if the request is authenticated</param>
+        /// <param name="nestedPropertyForCompare">Property to use for compare</param>
+        /// <param name="stjCompare">Use System.Text.Json for comparing</param>
+        public RestRequestValidator(TClient client, string folder, string baseAddress, Func<WebCallResult, bool> isAuthenticated, string? nestedPropertyForCompare = null, bool stjCompare = true)
+        {
+            _client = client;
+            _folder = folder;
+            _baseAddress = baseAddress;
+            _nestedPropertyForCompare = nestedPropertyForCompare;
+            _isAuthenticated = isAuthenticated;
+            _stjCompare = stjCompare;
+        }
+
+        /// <summary>
+        /// Validate a request
+        /// </summary>
+        /// <typeparam name="TResponse">Expected response type</typeparam>
+        /// <param name="methodInvoke">Method invocation</param>
+        /// <param name="name">Method name for looking up json test values</param>
+        /// <param name="nestedJsonProperty">Use nested json property for compare</param>
+        /// <param name="ignoreProperties">Ignore certain properties</param>
+        /// <param name="useSingleArrayItem">Use the first item of an json array response</param>
+        /// <param name="skipResponseValidation">Whether to skip the response model validation</param>
+        /// <returns></returns>
+        /// <exception cref="Exception"></exception>
+        public Task ValidateAsync<TResponse>(
+           Func<TClient, Task<WebCallResult<TResponse>>> methodInvoke,
+           string name,
+           string? nestedJsonProperty = null,
+           List<string>? ignoreProperties = null,
+           bool useSingleArrayItem = false,
+            bool skipResponseValidation = false)
+            => ValidateAsync<TResponse, TResponse>(methodInvoke, name, nestedJsonProperty, ignoreProperties, useSingleArrayItem, skipResponseValidation);
+
+        /// <summary>
+        /// Validate a request
+        /// </summary>
+        /// <typeparam name="TResponse">Expected response type</typeparam>
+        /// <typeparam name="TActualResponse">The concrete response type</typeparam>
+        /// <param name="methodInvoke">Method invocation</param>
+        /// <param name="name">Method name for looking up json test values</param>
+        /// <param name="nestedJsonProperty">Use nested json property for compare</param>
+        /// <param name="ignoreProperties">Ignore certain properties</param>
+        /// <param name="useSingleArrayItem">Use the first item of an json array response</param>
+        /// <param name="skipResponseValidation">Whether to skip the response model validation</param>
+        /// <returns></returns>
+        /// <exception cref="Exception"></exception>
+        public async Task ValidateAsync<TResponse, TActualResponse>(
+            Func<TClient, Task<WebCallResult<TResponse>>> methodInvoke,
+            string name,
+            string? nestedJsonProperty = null,
+            List<string>? ignoreProperties = null,
+            bool useSingleArrayItem = false,
+            bool skipResponseValidation = false) where TActualResponse : TResponse
+        {
+            var listener = new EnumValueTraceListener();
+            Trace.Listeners.Add(listener);
+            
+            var path = Directory.GetParent(Environment.CurrentDirectory)!.Parent!.Parent!.FullName;
+            FileStream file;
+            try
+            {
+                file = File.OpenRead(Path.Combine(path, _folder, $"{name}.txt"));
+            }
+            catch (FileNotFoundException)
+            {
+                throw new Exception($"Response file not found for {name}: {path}");
+            }
+
+            var buffer = new byte[file.Length];
+            await file.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
+            file.Close();
+
+            var data = Encoding.UTF8.GetString(buffer);
+            using var reader = new StringReader(data);
+            var expectedMethod = reader.ReadLine();
+            var expectedPath = reader.ReadLine();
+            var expectedAuth = bool.Parse(reader.ReadLine()!);
+            var response = reader.ReadToEnd();
+
+            TestHelpers.ConfigureRestClient(_client, response, System.Net.HttpStatusCode.OK);
+            var result = await methodInvoke(_client).ConfigureAwait(false);
+
+            // Check request/response properties
+            if (result.Error != null)
+                throw new Exception(name + " returned error " + result.Error);
+            if (_isAuthenticated(result.AsDataless()) != expectedAuth)
+                throw new Exception(name + $" authentication not matched. Expected: {expectedAuth}, Actual: {_isAuthenticated(result.AsDataless())}");
+            if (result.RequestMethod != new HttpMethod(expectedMethod!))
+                throw new Exception(name + $" http method not matched. Expected {expectedMethod}, Actual: {result.RequestMethod}");
+            if (expectedPath != result.RequestUrl!.Replace(_baseAddress, "").Split(new char[] { '?' })[0])
+                throw new Exception(name + $" path not matched. Expected: {expectedPath}, Actual: {result.RequestUrl!.Replace(_baseAddress, "").Split(new char[] { '?' })[0]}");
+
+            if (!skipResponseValidation)
+            {
+                // Check response data
+                object responseData = (TActualResponse)result.Data!;
+                if (_stjCompare == true)
+                    SystemTextJsonComparer.CompareData(name, responseData, response, nestedJsonProperty ?? _nestedPropertyForCompare, ignoreProperties, useSingleArrayItem);
+                else
+                    JsonNetComparer.CompareData(name, responseData, response, nestedJsonProperty ?? _nestedPropertyForCompare, ignoreProperties, useSingleArrayItem);
+            }
+
+            Trace.Listeners.Remove(listener);
+        }
+
+        /// <summary>
+        /// Validate a request
+        /// </summary>
+        /// <param name="methodInvoke">Method invocation</param>
+        /// <param name="name">Method name for looking up json test values</param>
+        /// <returns></returns>
+        /// <exception cref="Exception"></exception>
+        public async Task ValidateAsync(
+            Func<TClient, Task<WebCallResult>> methodInvoke,
+            string name)
+        {
+            var listener = new EnumValueTraceListener();
+            Trace.Listeners.Add(listener);
+
+            var path = Directory.GetParent(Environment.CurrentDirectory)!.Parent!.Parent!.FullName;
+            FileStream file;
+            try
+            {
+                file = File.OpenRead(Path.Combine(path, _folder, $"{name}.txt"));
+            }
+            catch (FileNotFoundException)
+            {
+                throw new Exception($"Response file not found for {name}: {path}");
+            }
+
+            var buffer = new byte[file.Length];
+            await file.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
+            file.Close();
+
+            var data = Encoding.UTF8.GetString(buffer);
+            using var reader = new StringReader(data);
+            var expectedMethod = reader.ReadLine();
+            var expectedPath = reader.ReadLine();
+            var expectedAuth = bool.Parse(reader.ReadLine()!);
+            var response = reader.ReadToEnd();
+
+            TestHelpers.ConfigureRestClient(_client, response, System.Net.HttpStatusCode.OK);
+            var result = await methodInvoke(_client).ConfigureAwait(false);
+
+            // Check request/response properties
+            if (result.Error != null)
+                throw new Exception(name + " returned error " + result.Error);
+            if (_isAuthenticated(result) != expectedAuth)
+                throw new Exception(name + $" authentication not matched. Expected: {expectedAuth}, Actual: {_isAuthenticated(result)}");
+            if (result.RequestMethod != new HttpMethod(expectedMethod!))
+                throw new Exception(name + $" http method not matched. Expected {expectedMethod}, Actual: {result.RequestMethod}");
+            if (expectedPath != result.RequestUrl!.Replace(_baseAddress, "").Split(new char[] { '?' })[0])
+                throw new Exception(name + $" path not matched. Expected: {expectedPath}, Actual: {result.RequestUrl!.Replace(_baseAddress, "").Split(new char[] { '?' })[0]}");
+
+            Trace.Listeners.Remove(listener);
+        }
+    }
+}

CryptoExchange.Net/Testing/SocketSubscriptionValidator.cs

@@ -0,0 +1,170 @@
+using CryptoExchange.Net.Clients;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Testing.Comparers;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Testing
+{
+    /// <summary>
+    /// Validator for websocket subscriptions, checking expected requests and responses and comparing update models
+    /// </summary>
+    /// <typeparam name="TClient"></typeparam>
+    public class SocketSubscriptionValidator<TClient> where TClient : BaseSocketClient
+    {
+        private readonly TClient _client;
+        private readonly string _folder;
+        private readonly string _baseAddress;
+        private readonly string? _nestedPropertyForCompare;
+        private readonly bool _stjCompare;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="client">Client to test</param>
+        /// <param name="folder">Folder for json test values</param>
+        /// <param name="baseAddress">The base address that is expected</param>
+        /// <param name="nestedPropertyForCompare">Property to use for compare</param>
+        /// <param name="stjCompare">Use System.Text.Json for comparing</param>
+        public SocketSubscriptionValidator(TClient client, string folder, string baseAddress, string? nestedPropertyForCompare = null, bool stjCompare = true)
+        {
+            _client = client;
+            _folder = folder;
+            _baseAddress = baseAddress;
+            _nestedPropertyForCompare = nestedPropertyForCompare;
+            _stjCompare = stjCompare;
+        }
+
+        /// <summary>
+        /// Validate a subscription
+        /// </summary>
+        /// <typeparam name="TUpdate">The expected update type</typeparam>
+        /// <param name="methodInvoke">Subscription method invocation</param>
+        /// <param name="name">Method name for looking up json test values</param>
+        /// <param name="nestedJsonProperty">Use nested json property for compare</param>
+        /// <param name="ignoreProperties">Ignore certain properties</param>
+        /// <returns></returns>
+        /// <exception cref="Exception"></exception>
+        public async Task ValidateAsync<TUpdate>(
+            Func<TClient, Action<DataEvent<TUpdate>>, Task<CallResult<UpdateSubscription>>> methodInvoke,
+            string name,
+            string? nestedJsonProperty = null,
+            List<string>? ignoreProperties = null)
+        {
+            var listener = new EnumValueTraceListener();
+            Trace.Listeners.Add(listener);
+            
+            var path = Directory.GetParent(Environment.CurrentDirectory)!.Parent!.Parent!.FullName;
+            FileStream file ;
+            try
+            {
+                file = File.OpenRead(Path.Combine(path, _folder, $"{name}.txt"));
+            }
+            catch (FileNotFoundException)
+            {
+                throw new Exception("Response file not found");
+            }
+
+            var buffer = new byte[file.Length];
+            await file.ReadAsync(buffer, 0, (int)file.Length).ConfigureAwait(false);
+            file.Close();
+
+            var data = Encoding.UTF8.GetString(buffer);
+            using var reader = new StringReader(data);
+
+            var socket = TestHelpers.ConfigureSocketClient(_client);
+
+            var waiter = new AutoResetEvent(false);
+            string? lastMessage = null;
+            socket.OnMessageSend += (x) =>
+            {
+                lastMessage = x;
+                waiter.Set();
+            };
+
+            TUpdate? update = default;
+            // Invoke subscription method
+            var task = methodInvoke(_client, x => { update = x.Data; });
+
+            string? overrideKey = null;
+            string? overrideValue = null;
+            while (true)
+            {
+                var line = reader.ReadLine();
+                if (line == null)
+                    break;
+
+                if (line.StartsWith("> "))
+                {
+                    // Expect a message from client to server
+                    waiter.WaitOne(TimeSpan.FromSeconds(1));
+
+                    if (lastMessage == null)
+                        throw new Exception($"{name} expected to {line} to be send to server but did not receive anything");
+
+
+                    var lastMessageJson = JToken.Parse(lastMessage);
+                    var expectedJson = JToken.Parse(line.Substring(2));
+                    foreach(var item in expectedJson)
+                    {
+                        if (item is JProperty prop && prop.Value is JValue val)
+                        {
+                            if (val.ToString().StartsWith("|") && val.ToString().EndsWith("|"))
+                            {
+                                // |x| values are used to replace parts or response messages
+                                overrideKey = val.ToString();
+                                overrideValue = lastMessageJson[prop.Name]?.Value<string>();
+                            }
+                            else if (val.ToString() == "-999")
+                            {
+                                // -999 value is used to replace parts or response messages
+                                overrideKey = val.ToString();
+                                overrideValue = lastMessageJson[prop.Name]?.Value<decimal>().ToString();
+                            }
+                            else if (lastMessageJson[prop.Name]?.Value<string>() != val.ToString() && ignoreProperties?.Contains(prop.Name) != true)
+                                throw new Exception($"{name} Expected {prop.Name} to be {val}, but was {lastMessageJson[prop.Name]?.Value<string>()}");
+                        }
+
+                        // TODO check objects and arrays
+                    }
+                }
+                else if (line.StartsWith("< "))
+                {
+                    // Expect a message from server to client
+                    if (overrideKey != null)
+                    {
+                        line = line.Replace(overrideKey, overrideValue);
+                        overrideKey = null;
+                        overrideValue = null;
+                    }
+
+                    socket.InvokeMessage(line.Substring(2));
+                }
+                else
+                {
+                    // A update message from server to client
+                    var compareData = reader.ReadToEnd();
+                    socket.InvokeMessage(compareData);
+
+                    if (update == null)
+                        throw new Exception($"{name} Update send to client did not trigger in update handler");
+
+                    if (_stjCompare == true)
+                        SystemTextJsonComparer.CompareData(name, update, compareData, nestedJsonProperty ?? _nestedPropertyForCompare, ignoreProperties);
+                    else
+                        JsonNetComparer.CompareData(name, update, compareData, nestedJsonProperty ?? _nestedPropertyForCompare, ignoreProperties);
+                }
+            }
+
+            await _client.UnsubscribeAllAsync().ConfigureAwait(false);
+            Trace.Listeners.Remove(listener);
+        }
+    }
+}

CryptoExchange.Net/Testing/TestHelpers.cs

@@ -0,0 +1,191 @@
+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.Net.Sockets;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Clients;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Testing.Implementations;
+
+namespace CryptoExchange.Net.Testing
+{
+    /// <summary>
+    /// Testing helpers
+    /// </summary>
+    public class TestHelpers
+    {
+        [ExcludeFromCodeCoverage]
+        internal static bool AreEqual<T>(T? self, T? to, params string[] ignore) where T : class
+        {
+            if (self != null && to != null)
+            {
+                var type = self.GetType();
+                var ignoreList = new List<string>(ignore);
+                foreach (var pi in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
+                {
+                    if (ignoreList.Contains(pi.Name))
+                        continue;
+
+                    var selfValue = type.GetProperty(pi.Name)!.GetValue(self, null);
+                    var toValue = type.GetProperty(pi.Name)!.GetValue(to, null);
+
+                    if (pi.PropertyType.IsClass && !pi.PropertyType.Module.ScopeName.Equals("System.Private.CoreLib.dll"))
+                    {
+                        // Check of "CommonLanguageRuntimeLibrary" is needed because string is also a class
+                        if (AreEqual(selfValue, toValue, ignore))
+                            continue;
+
+                        return false;
+                    }
+
+                    if (selfValue != toValue && (selfValue == null || !selfValue.Equals(toValue)))
+                        return false;
+                }
+
+                return true;
+            }
+
+            return self == to;
+        }
+
+        internal static TestSocket ConfigureSocketClient<T>(T client) where T : BaseSocketClient
+        {
+            var socket = new TestSocket();
+            foreach (var apiClient in client.ApiClients.OfType<SocketApiClient>())
+            {
+                apiClient.SocketFactory = new TestWebsocketFactory(socket);
+            }
+            return socket;
+        }
+
+        internal static void ConfigureRestClient<T>(T client, string data, HttpStatusCode code) where T : BaseRestClient
+        {
+            foreach (var apiClient in client.ApiClients.OfType<RestApiClient>())
+            {
+                var expectedBytes = Encoding.UTF8.GetBytes(data);
+                var responseStream = new MemoryStream();
+                responseStream.Write(expectedBytes, 0, expectedBytes.Length);
+                responseStream.Seek(0, SeekOrigin.Begin);
+
+                var response = new TestResponse(code, responseStream);
+                var request = new TestRequest(response);
+
+                var factory = new TestRequestFactory(request);
+                apiClient.RequestFactory = factory;
+            }
+        }
+
+        /// <summary>
+        /// Check a signature matches the expected signature
+        /// </summary>
+        /// <param name="client"></param>
+        /// <param name="authProvider"></param>
+        /// <param name="method"></param>
+        /// <param name="path"></param>
+        /// <param name="getSignature"></param>
+        /// <param name="expectedSignature"></param>
+        /// <param name="parameters"></param>
+        /// <param name="time"></param>
+        /// <param name="disableOrdering"></param>
+        /// <param name="compareCase"></param>
+        /// <param name="host"></param>
+        /// <exception cref="Exception"></exception>
+        public static void CheckSignature(
+            RestApiClient client,
+            AuthenticationProvider authProvider,
+            HttpMethod method,
+            string path,
+            Func<IDictionary<string, object>?, IDictionary<string, object>?, IDictionary<string, string>?, string> getSignature,
+            string expectedSignature,
+            Dictionary<string, object>? parameters = null,
+            DateTime? time = null,
+            bool disableOrdering = false,
+            bool compareCase = true,
+            string host = "https://test.test-api.com")
+        {
+            parameters ??= new Dictionary<string, object>
+                {
+                    { "test", 123 },
+                    { "test2", "abc" }
+                };
+
+            if (disableOrdering)
+                client.OrderParameters = false;
+
+            var uriParams = client.ParameterPositions[method] == HttpMethodParameterPosition.InUri ? client.CreateParameterDictionary(parameters) : new Dictionary<string, object>();
+            var bodyParams = client.ParameterPositions[method] == HttpMethodParameterPosition.InBody ? client.CreateParameterDictionary(parameters) : new Dictionary<string, object>();
+
+            var headers = new Dictionary<string, string>();
+
+            authProvider.TimeProvider = new TestAuthTimeProvider(time ?? new DateTime(2024, 01, 01, 0, 0, 0, DateTimeKind.Utc));
+            authProvider.AuthenticateRequest(
+                client, 
+                new Uri(host.AppendPath(path)), 
+                method,
+                uriParams,
+                bodyParams,
+                headers,
+                true,
+                client.ArraySerialization, 
+                client.ParameterPositions[method],
+                client.RequestBodyFormat
+                );
+
+            var signature = getSignature(uriParams, bodyParams, headers);
+
+            if (!string.Equals(signature, expectedSignature, compareCase ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase))
+                throw new Exception($"Signatures do not match. Expected: {expectedSignature}, Actual: {signature}");
+        }
+
+        /// <summary>
+        /// Scan the TClient rest client type for missing interface methods
+        /// </summary>
+        /// <typeparam name="TClient"></typeparam>
+        /// <exception cref="Exception"></exception>
+        public static void CheckForMissingRestInterfaces<TClient>()
+        {
+            CheckForMissingInterfaces(typeof(TClient), typeof(Task));
+        }
+
+        /// <summary>
+        /// Scan the TClient socket client type for missing interface methods
+        /// </summary>
+        /// <typeparam name="TClient"></typeparam>
+        /// <exception cref="Exception"></exception>
+        public static void CheckForMissingSocketInterfaces<TClient>()
+        {
+            CheckForMissingInterfaces(typeof(TClient), typeof(Task<CallResult<UpdateSubscription>>));
+        }
+
+        private static void CheckForMissingInterfaces(Type clientType, Type implementationTypes)
+        {
+            var assembly = Assembly.GetAssembly(clientType);
+            var interfaceType = clientType.GetInterface("I" + clientType.Name);
+            var clientInterfaces = assembly.GetTypes().Where(t => t.Name.StartsWith("I" + clientType.Name));
+
+            foreach (var clientInterface in clientInterfaces)
+            {
+                var implementation = assembly.GetTypes().Single(t => clientInterface.IsAssignableFrom(t) && t != clientInterface);
+                int methods = 0;
+                foreach (var method in implementation.GetMethods().Where(m => implementationTypes.IsAssignableFrom(m.ReturnType)))
+                {
+                    var interfaceMethod = clientInterface.GetMethod(method.Name, method.GetParameters().Select(p => p.ParameterType).ToArray());
+                    if (interfaceMethod == null)
+                        throw new Exception($"Missing interface for method {method.Name} in {implementation.Name} implementing interface {clientInterface.Name}");
+                    methods++;
+                }
+
+                Debug.WriteLine($"{clientInterface.Name} {methods} methods validated");
+            }
+        }
+    }
+}

Examples/BlazorClient/BlazorClient.csproj

@@ -5,15 +5,16 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Binance.Net" Version="9.5.0" />
+    <PackageReference Include="Binance.Net" Version="9.7.1" />
-    <PackageReference Include="Bitfinex.Net" Version="7.1.0" />
+    <PackageReference Include="Bitfinex.Net" Version="7.2.2" />
-    <PackageReference Include="Bybit.Net" Version="3.4.0" />
+    <PackageReference Include="Bybit.Net" Version="3.7.1" />
-    <PackageReference Include="CoinEx.Net" Version="6.1.0" />
+    <PackageReference Include="CoinEx.Net" Version="6.2.1" />
-    <PackageReference Include="Huobi.Net" Version="5.1.0" />
+    <PackageReference Include="Huobi.Net" Version="5.2.1" />
-    <PackageReference Include="JK.Bitget.Net" Version="1.1.0" />
+    <PackageReference Include="JK.BingX.Net" Version="1.0.0" />
-    <PackageReference Include="JK.OKX.Net" Version="1.6.0" />
+    <PackageReference Include="JK.Bitget.Net" Version="1.3.1" />
-    <PackageReference Include="KrakenExchange.Net" Version="4.3.0" />
+    <PackageReference Include="JK.OKX.Net" Version="1.7.1" />
-    <PackageReference Include="Kucoin.Net" Version="5.2.0" />
+    <PackageReference Include="KrakenExchange.Net" Version="4.4.3" />
+    <PackageReference Include="Kucoin.Net" Version="5.3.2" />
     <PackageReference Include="Serilog.AspNetCore" Version="6.0.0" />
   </ItemGroup>
 

Examples/BlazorClient/Pages/Index.razor

@@ -1,5 +1,6 @@
 @page "/"
 @inject IBinanceRestClient binanceClient
+@inject IBingXRestClient bingXClient
 @inject IBitfinexRestClient bitfinexClient
 @inject IBitgetRestClient bitgetClient
 @inject IBybitRestClient bybitClient
@@ -21,6 +22,7 @@
     protected override async Task OnInitializedAsync()
     {
         var binanceTask = binanceClient.SpotApi.ExchangeData.GetTickerAsync("BTCUSDT");
+        var bingXTask = bingXClient.SpotApi.ExchangeData.GetTickersAsync("BTC-USDT");
         var bitfinexTask = bitfinexClient.SpotApi.ExchangeData.GetTickerAsync("tBTCUSD");
         var bitgetTask = bitgetClient.SpotApi.ExchangeData.GetTickerAsync("BTCUSDT_SPBL");
         var bybitTask = bybitClient.V5Api.ExchangeData.GetSpotTickersAsync("BTCUSDT");
@@ -30,10 +32,13 @@
         var kucoinTask = kucoinClient.SpotApi.ExchangeData.GetTickerAsync("BTC-USDT");
         var okxTask = okxClient.UnifiedApi.ExchangeData.GetTickerAsync("BTCUSDT");
 
-        await Task.WhenAll(binanceTask, bitfinexTask, bybitTask, coinexTask, huobiTask, krakenTask, kucoinTask);
+        await Task.WhenAll(binanceTask, bingXTask, bitfinexTask, bybitTask, coinexTask, huobiTask, krakenTask, kucoinTask);
 
         if (binanceTask.Result.Success)
             _prices.Add("Binance", binanceTask.Result.Data.LastPrice);
+            
+        if (bingXTask.Result.Success)
+            _prices.Add("BingX", bingXTask.Result.Data.First().LastPrice);
 
         if (bitfinexTask.Result.Success)
             _prices.Add("Bitfinex", bitfinexTask.Result.Data.LastPrice);

Examples/BlazorClient/Pages/LiveData.razor

@@ -1,5 +1,6 @@
 @page "/LiveData"
 @inject IBinanceSocketClient binanceSocketClient
+@inject IBingXSocketClient bingXSocketClient
 @inject IBitfinexSocketClient bitfinexSocketClient
 @inject IBitgetSocketClient bitgetSocketClient
 @inject IBybitSocketClient bybitSocketClient
@@ -29,6 +30,7 @@
         var tasks = new Task<CallResult<UpdateSubscription>>[]
         {
             binanceSocketClient.SpotApi.ExchangeData.SubscribeToTickerUpdatesAsync("ETHBTC", data => UpdateData("Binance", data.Data.LastPrice)),
+            bingXSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ETH-BTC", data => UpdateData("BingX", data.Data.LastPrice)),
             bitfinexSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("tETHBTC", data => UpdateData("Bitfinex", data.Data.LastPrice)),
             bitgetSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ETHBTC", data => UpdateData("Bitget", data.Data.LastPrice)),
             bybitSocketClient.V5SpotApi.SubscribeToTickerUpdatesAsync("ETHBTC", data => UpdateData("Bybit", data.Data.LastPrice)),

Examples/BlazorClient/Pages/OrderBooks.razor

@@ -2,6 +2,7 @@
 @using System.Collections.Concurrent
 @using System.Timers
 @using Binance.Net.Interfaces
+@using BingX.Net.Interfaces
 @using Bitfinex.Net.Interfaces
 @using Bitget.Net.Interfaces;
 @using Bybit.Net.Interfaces
@@ -13,6 +14,7 @@
 @using Kucoin.Net.Interfaces
 @using OKX.Net.Interfaces;
 @inject IBinanceOrderBookFactory binanceFactory
+@inject IBingXOrderBookFactory bingXFactory
 @inject IBitfinexOrderBookFactory bitfinexFactory
 @inject IBitgetOrderBookFactory bitgetFactory
 @inject IBybitOrderBookFactory bybitFactory
@@ -55,6 +57,7 @@
         _books = new Dictionary<string, ISymbolOrderBook>
             {
                 { "Binance", binanceFactory.CreateSpot("ETHBTC") },
+                { "BingX", bingXFactory.CreateSpot("ETH-BTC") },
                 { "Bitfinex", bitfinexFactory.Create("tETHBTC") },
                 { "Bitget", bitgetFactory.CreateSpot("ETHBTC") },
                 { "Bybit", bybitFactory.Create("ETHBTC", Bybit.Net.Enums.Category.Spot) },

Examples/BlazorClient/Startup.cs

@@ -36,6 +36,7 @@ namespace BlazorClient
                 socketOptions.ApiCredentials = new ApiCredentials("KEY", "SECRET");
             });
 
+            services.AddBingX();
             services.AddBitfinex();
             services.AddBitget();
             services.AddBybit();

Examples/BlazorClient/_Imports.razor

@@ -9,6 +9,7 @@
 @using BlazorClient
 @using BlazorClient.Shared
 @using Binance.Net.Interfaces.Clients;
+@using BingX.Net.Interfaces.Clients;
 @using Bitfinex.Net.Interfaces.Clients;
 @using Bitget.Net.Interfaces.Clients;
 @using Bybit.Net.Interfaces.Clients;

README.md

@@ -3,6 +3,7 @@
 [![.NET](https://img.shields.io/github/actions/workflow/status/JKorf/CryptoExchange.Net/dotnet.yml?style=for-the-badge)](https://github.com/JKorf/CryptoExchange.Net/actions/workflows/dotnet.yml) [![Nuget downloads](https://img.shields.io/nuget/dt/CryptoExchange.Net.svg?style=for-the-badge)](https://www.nuget.org/packages/CryptoExchange.Net) ![License](https://img.shields.io/github/license/JKorf/CryptoExchange.Net?style=for-the-badge)
 
 CryptoExchange.Net is a base library which is used to implement different cryptocurrency (exchange) API's. It provides a standardized way of implementing different API's, which results in a very similar experience for users of the API implementations. 
+Note that the CryptoExchange.Net package itself can not be used directly for accessing API's. Either install a client library from the list below or use [CryptoClients.Net](https://github.com/jkorf/CryptoClients.Net) which includes access to all exchange API's.
 
 For more information on what CryptoExchange.Net and it's client libraries offers see the [Documentation](https://jkorf.github.io/CryptoExchange.Net/).
 
@@ -12,6 +13,7 @@ The following API's are directly supported. Note that there are 3rd party implem
 |Exchange|Repository|Nuget|
 |--|--|--|
 |Binance|[JKorf/Binance.Net](https://github.com/JKorf/Binance.Net)|[![Nuget version](https://img.shields.io/nuget/v/Binance.net.svg?style=flat-square)](https://www.nuget.org/packages/Binance.Net)|
+|BingX|[JKorf/BingX.Net](https://github.com/JKorf/BingX.Net)|[![Nuget version](https://img.shields.io/nuget/v/JK.BingX.net.svg?style=flat-square)](https://www.nuget.org/packages/JK.BingX.Net)|
 |Bitfinex|[JKorf/Bitfinex.Net](https://github.com/JKorf/Bitfinex.Net)|[![Nuget version](https://img.shields.io/nuget/v/Bitfinex.net.svg?style=flat-square)](https://www.nuget.org/packages/Bitfinex.Net)|
 |Bitget|[JKorf/Bitget.Net](https://github.com/JKorf/Bitget.Net)|[![Nuget version](https://img.shields.io/nuget/v/JK.Bitget.net.svg?style=flat-square)](https://www.nuget.org/packages/JK.Bitget.Net)|
 |Bybit|[JKorf/Bybit.Net](https://github.com/JKorf/Bybit.Net)|[![Nuget version](https://img.shields.io/nuget/v/Bybit.net.svg?style=flat-square)](https://www.nuget.org/packages/Bybit.Net)|
@@ -23,6 +25,8 @@ The following API's are directly supported. Note that there are 3rd party implem
 |Mexc|[JKorf/Mexc.Net](https://github.com/JKorf/Mexc.Net)|[![Nuget version](https://img.shields.io/nuget/v/JK.Mexc.net.svg?style=flat-square)](https://www.nuget.org/packages/JK.Mexc.Net)|
 |OKX|[JKorf/OKX.Net](https://github.com/JKorf/OKX.Net)|[![Nuget version](https://img.shields.io/nuget/v/JK.OKX.net.svg?style=flat-square)](https://www.nuget.org/packages/JK.OKX.Net)|
 
+Any of these can be installed independently or install [CryptoClients.Net](https://github.com/jkorf/CryptoClients.Net) which includes all exchange API's.
+
 ## Discord
 [![Nuget version](https://img.shields.io/discord/847020490588422145?style=for-the-badge)](https://discord.gg/MSpeEtSY8t)  
 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.
@@ -33,13 +37,59 @@ I develop and maintain this package on my own for free in my spare time, any sup
 ### 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  
+**Btc**:  bc1q277a5n54s2l2mzlu778ef7lpkwhjhyvghuv8qf  
-**Eth**:  0xcb1b63aCF9fef2755eBf4a0506250074496Ad5b7  
+**Eth**:  0xcb1b63aCF9fef2755eBf4a0506250074496Ad5b7   
+**USDT (TRX)**  TKigKeJPXZYyMVDgMyXxMf17MWYia92Rjd
 
 ### Sponsor
 Alternatively, sponsor me on Github using [Github Sponsors](https://github.com/sponsors/JKorf). 
 
 ## Release notes
+* Version 7.5.2 - 07 May 2024
+    * Fixed SetApiCredentials not correctly being used by rate limiter causing exception
+
+* Version 7.5.1 - 03 May 2024
+    * Some small improvements in unit testing components
+
+* Version 7.5.0 - 01 May 2024
+    * Added testing implementations
+    * Small refactor AuthenticationProvider to allow better testing
+    * Change result of MessageAccessor.Read methods to CallResult so error can be returned
+    * Moved some DateTimeConverter logic to seperate methods to allow access from outside converters
+
+* Version 7.4.0 - 28 Apr 2024
+    * Added FormatSymbol on IBaseApiClient interface
+    * Added IOrderBookFactory interface
+    * Removed ExchangeOptions as base class for OrderBookOptions
+
+* Version 7.3.3 - 23 Apr 2024
+    * Added support for new DateTime format parsing
+    * Updated some logging
+    * Fixed concurrency issue in rest request sending
+
+* Version 7.3.2 - 19 Apr 2024
+    * Fix for endpoint specific rate limiting throwing exception
+
+* Version 7.3.1 - 18 Apr 2024
+    * Fixed websocket system subscriptions getting marked as unconfirmed when reconnecting
+
+* Version 7.3.0 - 17 Apr 2024
+    * Added new method for sending Rest requests which splits the static and dynamic parameters
+	* Refactored rate limiting implementation
+		* Ratelimiters now statically applied for all clients
+		* Added support for different rate limit window types
+		* Added modular configuration of rate limits
+		* Added rate limit check when creating websocket connections
+		* Added automatic handling and retry for Retry-After responses
+		* Added configuration for setting ratelimit for each individual endpoint
+		* Added event for when rate limit is triggered
+	* Added SocketClient GetSocketApiClientStates method
+
+* Version 7.2.1 - 05 Apr 2024
+    * Improved websocket reconnect logic
+    * Simplified SystemTextJsonMessageAccessor value retrieval
+    * Fixed System.Text.Json BoolConverter value writing
+
 * Version 7.2.0 - 24 Mar 2024
     * Added ArrayParametersSerialization.JsonArray support
     * Refactored to high-performance logging for hot paths

docs/README.md

@@ -0,0 +1 @@
+Source for https://jkorf.github.io/CryptoExchange.Net