Updated to version 8.0.1

* feature: Handle error 429 when connecting websocket

* Add preprocessor directive for NET6_0_OR_GREATER when checking for connection rate limit

.github/workflows/dotnet.yml

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

CryptoExchange.Net.UnitTests/CallResultTests.cs

@@ -121,6 +121,7 @@ namespace CryptoExchange.Net.UnitTests
                 null,
                 HttpMethod.Get,
                 new List<KeyValuePair<string, IEnumerable<string>>>(),
+                ResultDataSource.Server,
                 new TestObjectResult(),
                 null);
             var asResult = result.AsError<TestObject2>(new ServerError("TestError2"));
@@ -150,6 +151,7 @@ namespace CryptoExchange.Net.UnitTests
                 null,
                 HttpMethod.Get,
                 new List<KeyValuePair<string, IEnumerable<string>>>(),
+                ResultDataSource.Server,
                 new TestObjectResult(),
                 null);
             var asResult = result.As<TestObject2>(result.Data.InnerData);

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

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 

CryptoExchange.Net.UnitTests/OptionsTests.cs

@@ -51,8 +51,8 @@ namespace CryptoExchange.Net.UnitTests
 
             // assert
             Assert.That(options.ReceiveWindow == TimeSpan.FromSeconds(10));
-            Assert.That(options.ApiCredentials.Key.GetString() == "123");
-            Assert.That(options.ApiCredentials.Secret.GetString() == "456");
+            Assert.That(options.ApiCredentials.Key == "123");
+            Assert.That(options.ApiCredentials.Secret == "456");
         }
 
         [Test]
@@ -64,10 +64,10 @@ namespace CryptoExchange.Net.UnitTests
             options.Api2Options.ApiCredentials = new ApiCredentials("789", "101");
 
             // assert
-            Assert.That(options.Api1Options.ApiCredentials.Key.GetString() == "123");
-            Assert.That(options.Api1Options.ApiCredentials.Secret.GetString() == "456");
-            Assert.That(options.Api2Options.ApiCredentials.Key.GetString() == "789");
-            Assert.That(options.Api2Options.ApiCredentials.Secret.GetString() == "101");
+            Assert.That(options.Api1Options.ApiCredentials.Key == "123");
+            Assert.That(options.Api1Options.ApiCredentials.Secret == "456");
+            Assert.That(options.Api2Options.ApiCredentials.Key == "789");
+            Assert.That(options.Api2Options.ApiCredentials.Secret == "101");
         }
 
         [Test]

CryptoExchange.Net.UnitTests/RestClientTests.cs

@@ -176,12 +176,12 @@ namespace CryptoExchange.Net.UnitTests
 
             for (var i = 0; i < requests + 1; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);             
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);             
                 Assert.That(i == requests? triggered : !triggered);
             }
             triggered = false;
             await Task.Delay((int)Math.Round(perSeconds * 1000) + 10);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1,  RateLimitingBehaviour.Wait, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1,  RateLimitingBehaviour.Wait, default);
             Assert.That(!triggered);
         }
 
@@ -201,7 +201,7 @@ namespace CryptoExchange.Net.UnitTests
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
                 bool expected = i == 1 ? (expectLimiting ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
                 Assert.That(expected);
             }
@@ -222,9 +222,9 @@ namespace CryptoExchange.Net.UnitTests
             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);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(evnt == null);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(expectLimiting ? evnt != null : evnt == null);
         }
 
@@ -243,12 +243,12 @@ namespace CryptoExchange.Net.UnitTests
 
             for (var i = 0; i < requests + 1; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
                 Assert.That(i == requests ? triggered : !triggered);
             }
             triggered = false;
             await Task.Delay((int)Math.Round(perSeconds * 1000) + 10);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(!triggered);
         }
 
@@ -266,7 +266,7 @@ namespace CryptoExchange.Net.UnitTests
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
                 bool expected = i == 1 ? (expectLimited ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
                 Assert.That(expected);
             }
@@ -286,7 +286,7 @@ namespace CryptoExchange.Net.UnitTests
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
                 bool expected = i == 1 ? (expectLimited ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
                 Assert.That(expected);
             }
@@ -309,9 +309,9 @@ namespace CryptoExchange.Net.UnitTests
             RateLimitEvent evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", key1?.ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", key1, 1, RateLimitingBehaviour.Wait, default);
             Assert.That(evnt == null);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", key2?.ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", key2, 1, RateLimitingBehaviour.Wait, default);
             Assert.That(expectLimited ? evnt != null : evnt == null);
         }
 
@@ -328,7 +328,7 @@ namespace CryptoExchange.Net.UnitTests
             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);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(evnt == null);
             var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", null, 1, RateLimitingBehaviour.Wait, default);
             Assert.That(expectLimited ? evnt != null : evnt == null);
@@ -348,9 +348,9 @@ namespace CryptoExchange.Net.UnitTests
             RateLimitEvent evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, host1, "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, host1, "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(evnt == null);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, host2, "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, host2, "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(expectLimited ? evnt != null : evnt == null);
         }
 
@@ -365,10 +365,25 @@ namespace CryptoExchange.Net.UnitTests
             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);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), host1, "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(evnt == null);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), host2, "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), host2, "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(expectLimited ? evnt != null : evnt == null);
         }
+
+        [Test]
+        public async Task ConnectionRateLimiterCancel()
+        {
+            var rateLimiter = new RateLimitGate("Test");
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, new LimitItemTypeFilter(RateLimitItemType.Connection), 1, TimeSpan.FromSeconds(10), RateLimitWindowType.Fixed));
+
+            RateLimitEvent evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
+            var ct = new CancellationTokenSource(TimeSpan.FromSeconds(0.2));
+
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), "https://test.com", "123", 1, RateLimitingBehaviour.Wait, ct.Token);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), "https://test.com", "123", 1, RateLimitingBehaviour.Wait, ct.Token);
+            Assert.That(result2.Error, Is.TypeOf<CancellationRequestedError>());
+        }
     }
 }

CryptoExchange.Net.UnitTests/SocketClientTests.cs

@@ -58,9 +58,7 @@ namespace CryptoExchange.Net.UnitTests
                 options.ReconnectInterval = TimeSpan.Zero;
             });
             var socket = client.CreateSocket();
-            socket.ShouldReconnect = true;
             socket.CanConnect = true;
-            socket.DisconnectTime = DateTime.UtcNow;
             var sub = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
             var rstEvent = new ManualResetEvent(false);
             Dictionary<string, string> result = null;
@@ -75,7 +73,7 @@ namespace CryptoExchange.Net.UnitTests
             sub.AddSubscription(subObj);
 
             // act
-            socket.InvokeMessage("{\"property\": \"123\", \"topic\": \"topic\"}");
+            socket.InvokeMessage("{\"property\": \"123\", \"action\": \"update\", \"topic\": \"topic\"}");
             rstEvent.WaitOne(1000);
 
             // assert
@@ -93,9 +91,7 @@ namespace CryptoExchange.Net.UnitTests
                 options.SubOptions.OutputOriginalData = enabled;
             });
             var socket = client.CreateSocket();
-            socket.ShouldReconnect = true;
             socket.CanConnect = true;
-            socket.DisconnectTime = DateTime.UtcNow;
             var sub = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
             var rstEvent = new ManualResetEvent(false);
             string original = null;
@@ -107,7 +103,7 @@ namespace CryptoExchange.Net.UnitTests
                 rstEvent.Set();
             });
             sub.AddSubscription(subObj);
-            var msgToSend = JsonConvert.SerializeObject(new { topic = "topic", property = 123 });
+            var msgToSend = JsonConvert.SerializeObject(new { topic = "topic", action = "update", property = 123 });
 
             // act
             socket.InvokeMessage(msgToSend);
@@ -202,7 +198,7 @@ namespace CryptoExchange.Net.UnitTests
 
             // act
             var sub = client.SubClient.SubscribeToSomethingAsync(channel, onUpdate => {}, ct: default);
-            socket.InvokeMessage(JsonConvert.SerializeObject(new { channel, status = "error" }));
+            socket.InvokeMessage(JsonConvert.SerializeObject(new { channel, action = "subscribe", status = "error" }));
             await sub;
 
             // assert
@@ -225,7 +221,7 @@ namespace CryptoExchange.Net.UnitTests
 
             // act
             var sub = client.SubClient.SubscribeToSomethingAsync(channel, onUpdate => {}, ct: default);
-            socket.InvokeMessage(JsonConvert.SerializeObject(new { channel, status = "confirmed" }));
+            socket.InvokeMessage(JsonConvert.SerializeObject(new { channel, action = "subscribe", status = "confirmed" }));
             await sub;
 
             // assert

CryptoExchange.Net.UnitTests/SystemTextJsonConverterTests.cs

@@ -163,6 +163,20 @@ namespace CryptoExchange.Net.UnitTests
             Assert.That(output.Value == expected);
         }
 
+        [TestCase("1", TestEnum.One)]
+        [TestCase("2", TestEnum.Two)]
+        [TestCase("3", TestEnum.Three)]
+        [TestCase("three", TestEnum.Three)]
+        [TestCase("Four", TestEnum.Four)]
+        [TestCase("four", TestEnum.Four)]
+        [TestCase("Four1", TestEnum.One)]
+        [TestCase(null, TestEnum.One)]
+        public void TestEnumConverterParseStringTests(string value, TestEnum? expected)
+        {
+            var result = EnumConverter.ParseString<TestEnum>(value);
+            Assert.That(result == expected);
+        }
+
         [TestCase("1", true)]
         [TestCase("true", true)]
         [TestCase("yes", true)]
@@ -200,6 +214,41 @@ namespace CryptoExchange.Net.UnitTests
             var output = JsonSerializer.Deserialize<NotNullableSTJBoolObject>($"{{ \"Value\": {val} }}");
             Assert.That(output.Value == expected);
         }
+
+        [TestCase("1", 1)]
+        [TestCase("1.1", 1.1)]
+        [TestCase("-1.1", -1.1)]
+        [TestCase(null, null)]
+        [TestCase("", null)]
+        [TestCase("null", null)]
+        [TestCase("1E+2", 100)]
+        [TestCase("1E-2", 0.01)]
+        [TestCase("80228162514264337593543950335", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
+        public void TestDecimalConverterString(string value, decimal? expected)
+        {
+            var result = JsonSerializer.Deserialize<STJDecimalObject>("{ \"test\": \""+ value + "\"}");
+            Assert.That(result.Test, Is.EqualTo(expected == -999 ? decimal.MaxValue : expected));
+        }
+
+        [TestCase("1", 1)]
+        [TestCase("1.1", 1.1)]
+        [TestCase("-1.1", -1.1)]
+        [TestCase("null", null)]
+        [TestCase("1E+2", 100)]
+        [TestCase("1E-2", 0.01)]
+        [TestCase("80228162514264337593543950335", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
+        public void TestDecimalConverterNumber(string value, decimal? expected)
+        {
+            var result = JsonSerializer.Deserialize<STJDecimalObject>("{ \"test\": " + value + "}");
+            Assert.That(result.Test, Is.EqualTo(expected == -999 ? decimal.MaxValue : expected));
+        }
+    }
+
+    public class STJDecimalObject
+    {
+        [JsonConverter(typeof(DecimalConverter))]
+        [JsonPropertyName("test")]
+        public decimal? Test { get; set; }
     }
 
     public class STJTimeObject

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

@@ -10,6 +10,10 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
 {
     internal class SubResponse
     {
+
+        [JsonProperty("action")]
+        public string Action { get; set; } = null!;
+
         [JsonProperty("channel")]
         public string Channel { get; set; } = null!;
 
@@ -19,6 +23,9 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
 
     internal class UnsubResponse
     {
+        [JsonProperty("action")]
+        public string Action { get; set; } = null!;
+
         [JsonProperty("status")]
         public string Status { get; set; } = null!;
     }
@@ -29,7 +36,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
 
         public TestChannelQuery(string channel, string request, bool authenticated, int weight = 1) : base(request, authenticated, weight)
         {
-            ListenerIdentifiers = new HashSet<string> { channel };
+            ListenerIdentifiers = new HashSet<string> { request + "-" + channel };
         }
 
         public override CallResult<SubResponse> HandleMessage(SocketConnection connection, DataEvent<SubResponse> message)

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

@@ -15,7 +15,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
     {
         private readonly Action<DataEvent<T>> _handler;
 
-        public override HashSet<string> ListenerIdentifiers { get; set; } = new HashSet<string> { "topic" };
+        public override HashSet<string> ListenerIdentifiers { get; set; } = new HashSet<string> { "update-topic" };
 
         public TestSubscription(ILogger logger, Action<DataEvent<T>> handler) : base(logger, false)
         {

CryptoExchange.Net.UnitTests/TestImplementations/TestBaseClient.cs

@@ -8,6 +8,7 @@ using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Clients;
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.SharedApis;
 using CryptoExchange.Net.UnitTests.TestImplementations;
 using Microsoft.Extensions.Logging;
 
@@ -55,7 +56,7 @@ namespace CryptoExchange.Net.UnitTests
         }
 
         /// <inheritdoc />
-        public override string FormatSymbol(string baseAsset, string quoteAsset) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
+        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode futuresType, DateTime? deliverDate = null) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
         public override TimeSpan? GetTimeOffset() => null;
         public override TimeSyncInfo GetTimeSyncInfo() => null;
         protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials) => throw new NotImplementedException();
@@ -68,11 +69,11 @@ namespace CryptoExchange.Net.UnitTests
         {
         }
 
-        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)
+        public override void AuthenticateRequest(RestApiClient apiClient, Uri uri, HttpMethod method, ref IDictionary<string, object> uriParams, ref IDictionary<string, object> bodyParams, ref Dictionary<string, string> headers, bool auth, ArrayParametersSerialization arraySerialization, HttpMethodParameterPosition parameterPosition, RequestBodyFormat bodyFormat)
         {
         }
 
-        public string GetKey() => _credentials.Key.GetString();
-        public string GetSecret() => _credentials.Secret.GetString();
+        public string GetKey() => _credentials.Key;
+        public string GetSecret() => _credentials.Secret;
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/TestRestClient.cs

@@ -15,6 +15,7 @@ using System.Collections.Generic;
 using CryptoExchange.Net.Objects.Options;
 using Microsoft.Extensions.Logging;
 using CryptoExchange.Net.Clients;
+using CryptoExchange.Net.SharedApis;
 
 namespace CryptoExchange.Net.UnitTests.TestImplementations
 {
@@ -138,7 +139,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
         }
 
         /// <inheritdoc />
-        public override string FormatSymbol(string baseAsset, string quoteAsset) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
+        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode futuresType, DateTime? deliverDate = null) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
 
         public async Task<CallResult<T>> Request<T>(CancellationToken ct = default) where T : class
         {
@@ -182,7 +183,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
         }
 
         /// <inheritdoc />
-        public override string FormatSymbol(string baseAsset, string quoteAsset) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
+        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode futuresType, DateTime? deliverDate = null) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
 
         public async Task<CallResult<T>> Request<T>(CancellationToken ct = default) where T : class
         {

CryptoExchange.Net.UnitTests/TestImplementations/TestSocket.cs

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

CryptoExchange.Net.UnitTests/TestImplementations/TestSocketClient.cs

@@ -13,11 +13,12 @@ using CryptoExchange.Net.Sockets;
 using CryptoExchange.Net.UnitTests.TestImplementations.Sockets;
 using Microsoft.Extensions.Logging;
 using Moq;
-using Newtonsoft.Json.Linq;
+using CryptoExchange.Net.Testing.Implementations;
+using CryptoExchange.Net.SharedApis;
 
 namespace CryptoExchange.Net.UnitTests.TestImplementations
 {
-    public class TestSocketClient: BaseSocketClient
+    internal class TestSocketClient: BaseSocketClient
     {
         public TestSubSocketClient SubClient { get; }
 
@@ -41,12 +42,12 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
 
             SubClient = AddApiClient(new TestSubSocketClient(options, options.SubOptions));
             SubClient.SocketFactory = new Mock<IWebsocketFactory>().Object;
-            Mock.Get(SubClient.SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<ILogger>(), It.IsAny<WebSocketParameters>())).Returns(new TestSocket());
+            Mock.Get(SubClient.SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<ILogger>(), It.IsAny<WebSocketParameters>())).Returns(new TestSocket("https://test.com"));
         }
 
         public TestSocket CreateSocket()
         {
-            Mock.Get(SubClient.SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<ILogger>(), It.IsAny<WebSocketParameters>())).Returns(new TestSocket());
+            Mock.Get(SubClient.SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<ILogger>(), It.IsAny<WebSocketParameters>())).Returns(new TestSocket("https://test.com"));
             return (TestSocket)SubClient.CreateSocketInternal("https://localhost:123/");
         }
                 
@@ -75,6 +76,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
     public class TestSubSocketClient : SocketApiClient
     {
         private MessagePath _channelPath = MessagePath.Get().Property("channel");
+        private MessagePath _actionPath = MessagePath.Get().Property("action");
         private MessagePath _topicPath = MessagePath.Get().Property("topic");
 
         public Subscription TestSubscription { get; private set; } = null;
@@ -85,7 +87,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
         }
 
         /// <inheritdoc />
-        public override string FormatSymbol(string baseAsset, string quoteAsset) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
+        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode futuresType, DateTime? deliverDate = null) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
 
         internal IWebsocket CreateSocketInternal(string address)
         {
@@ -110,7 +112,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             var id = message.GetValue<string>(_channelPath);
             id ??= message.GetValue<string>(_topicPath);
 
-            return id;
+            return message.GetValue<string>(_actionPath) + "-" + id;
         }
 
         public Task<CallResult<UpdateSubscription>> SubscribeToSomethingAsync(string channel, Action<DataEvent<string>> onUpdate, CancellationToken ct)

CryptoExchange.Net.sln

@@ -11,7 +11,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "BlazorClient", "Examples\Bl
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Examples", "Examples", "{5734C2A9-F12C-4754-A8B9-640C24DC4E02}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleClient", "Examples\ConsoleClient\ConsoleClient.csproj", "{23480C58-23BF-4EBF-A173-B7F51A043A99}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ConsoleClient", "Examples\ConsoleClient\ConsoleClient.csproj", "{23480C58-23BF-4EBF-A173-B7F51A043A99}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharedClients", "Examples\SharedClients\SharedClients.csproj", "{988A87EF-EAEA-4313-A6CF-FA869813D5AB}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -35,6 +37,10 @@ Global
 		{23480C58-23BF-4EBF-A173-B7F51A043A99}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{23480C58-23BF-4EBF-A173-B7F51A043A99}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{23480C58-23BF-4EBF-A173-B7F51A043A99}.Release|Any CPU.Build.0 = Release|Any CPU
+		{988A87EF-EAEA-4313-A6CF-FA869813D5AB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{988A87EF-EAEA-4313-A6CF-FA869813D5AB}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{988A87EF-EAEA-4313-A6CF-FA869813D5AB}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{988A87EF-EAEA-4313-A6CF-FA869813D5AB}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -42,6 +48,7 @@ Global
 	GlobalSection(NestedProjects) = preSolution
 		{AF4F5C19-162E-48F4-8B0B-BA5A2D7CE06A} = {5734C2A9-F12C-4754-A8B9-640C24DC4E02}
 		{23480C58-23BF-4EBF-A173-B7F51A043A99} = {5734C2A9-F12C-4754-A8B9-640C24DC4E02}
+		{988A87EF-EAEA-4313-A6CF-FA869813D5AB} = {5734C2A9-F12C-4754-A8B9-640C24DC4E02}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {0D1B9CE9-E0B7-4B8B-88BF-6EA2CC8CA3D7}

CryptoExchange.Net/Authentication/ApiCredentials.cs

@@ -1,6 +1,5 @@
 using System;
 using System.IO;
-using System.Security;
 using CryptoExchange.Net.Converters.SystemTextJson;
 using CryptoExchange.Net.Converters.MessageParsing;
 
@@ -9,17 +8,17 @@ namespace CryptoExchange.Net.Authentication
     /// <summary>
     /// Api credentials, used to sign requests accessing private endpoints
     /// </summary>
-    public class ApiCredentials: IDisposable
+    public class ApiCredentials
     {
         /// <summary>
-        /// The api key to authenticate requests
+        /// The api key / label to authenticate requests
         /// </summary>
-        public SecureString? Key { get; }
+        public string Key { get; }
 
         /// <summary>
-        /// The api secret to authenticate requests
+        /// The api secret or private key to authenticate requests
         /// </summary>
-        public SecureString? Secret { get; }
+        public string Secret { get; }
 
         /// <summary>
         /// Type of the credentials
@@ -29,21 +28,21 @@ namespace CryptoExchange.Net.Authentication
         /// <summary>
         /// Create Api credentials providing an api key and secret for authentication
         /// </summary>
-        /// <param name="key">The api key used for identification</param>
-        /// <param name="secret">The api secret used for signing</param>
-        public ApiCredentials(SecureString key, SecureString secret) : this(key, secret, ApiCredentialsType.Hmac)
+        /// <param name="key">The api key / label used for identification</param>
+        /// <param name="secret">The api secret or private key used for signing</param>
+        public ApiCredentials(string key, string secret) : this(key, secret, ApiCredentialsType.Hmac)
         {
         }
 
         /// <summary>
         /// Create Api credentials providing an api key and secret for authentication
         /// </summary>
-        /// <param name="key">The api key used for identification</param>
-        /// <param name="secret">The api secret used for signing</param>
+        /// <param name="key">The api key / label used for identification</param>
+        /// <param name="secret">The api secret or private key used for signing</param>
         /// <param name="credentialsType">The type of credentials</param>
-        public ApiCredentials(SecureString key, SecureString secret, ApiCredentialsType credentialsType)
+        public ApiCredentials(string key, string secret, ApiCredentialsType credentialsType)
         {
-            if (key == null || secret == null)
+            if (string.IsNullOrEmpty(key) || string.IsNullOrEmpty(secret))
                 throw new ArgumentException("Key and secret can't be null/empty");
 
             CredentialType = credentialsType;
@@ -51,39 +50,13 @@ namespace CryptoExchange.Net.Authentication
             Secret = secret;
         }
 
-        /// <summary>
-        /// Create Api credentials providing an api key and secret for authentication
-        /// </summary>
-        /// <param name="key">The api key used for identification</param>
-        /// <param name="secret">The api secret used for signing</param>
-        public ApiCredentials(string key, string secret) : this(key, secret, ApiCredentialsType.Hmac)
-        {
-        }
-
-        /// <summary>
-        /// Create Api credentials providing an api key and secret for authentication
-        /// </summary>
-        /// <param name="key">The api key used for identification</param>
-        /// <param name="secret">The api secret used for signing</param>
-        /// <param name="credentialsType">The type of credentials</param>
-        public ApiCredentials(string key, string secret, ApiCredentialsType credentialsType)
-        {
-            if (string.IsNullOrEmpty(key) || string.IsNullOrEmpty(secret))
-                throw new ArgumentException("Key and secret can't be null/empty");
-
-            CredentialType = credentialsType;
-            Key = key.ToSecureString();
-            Secret = secret.ToSecureString();
-        }
-
         /// <summary>
         /// Copy the credentials
         /// </summary>
         /// <returns></returns>
         public virtual ApiCredentials Copy()
         {
-            // Use .GetString() to create a copy of the SecureString
-            return new ApiCredentials(Key!.GetString(), Secret!.GetString(), CredentialType);
+            return new ApiCredentials(Key, Secret, CredentialType);
         }
 
         /// <summary>
@@ -103,19 +76,10 @@ namespace CryptoExchange.Net.Authentication
             if (key == null || secret == null)
                 throw new ArgumentException("apiKey or apiSecret value not found in Json credential file");
 
-            Key = key.ToSecureString();
-            Secret = secret.ToSecureString();
+            Key = key;
+            Secret = secret;
 
             inputStream.Seek(0, SeekOrigin.Begin);
         }
-
-        /// <summary>
-        /// Dispose
-        /// </summary>
-        public void Dispose()
-        {
-            Key?.Dispose();
-            Secret?.Dispose();
-        }
     }
 }

CryptoExchange.Net/Authentication/AuthenticationProvider.cs

@@ -14,7 +14,7 @@ namespace CryptoExchange.Net.Authentication
     /// <summary>
     /// Base class for authentication providers
     /// </summary>
-    public abstract class AuthenticationProvider : IDisposable
+    public abstract class AuthenticationProvider
     {
         internal IAuthTimeProvider TimeProvider { get; set; } = new AuthTimeProvider();
 
@@ -28,6 +28,11 @@ namespace CryptoExchange.Net.Authentication
         /// </summary>
         protected byte[] _sBytes;
 
+        /// <summary>
+        /// Get the API key of the current credentials
+        /// </summary>
+        public string ApiKey => _credentials.Key;
+
         /// <summary>
         /// ctor
         /// </summary>
@@ -38,7 +43,7 @@ namespace CryptoExchange.Net.Authentication
                 throw new ArgumentException("ApiKey/Secret needed");
 
             _credentials = credentials;
-            _sBytes = Encoding.UTF8.GetBytes(credentials.Secret.GetString());
+            _sBytes = Encoding.UTF8.GetBytes(credentials.Secret);
         }
 
         /// <summary>
@@ -58,9 +63,9 @@ namespace CryptoExchange.Net.Authentication
             RestApiClient apiClient,
             Uri uri,
             HttpMethod method,
-            IDictionary<string, object> uriParameters,
-            IDictionary<string, object> bodyParameters,
-            Dictionary<string, string> headers,
+            ref IDictionary<string, object>? uriParameters,
+            ref IDictionary<string, object>? bodyParameters,
+            ref Dictionary<string, string>? headers,
             bool auth,
             ArrayParametersSerialization arraySerialization,
             HttpMethodParameterPosition parameterPosition,
@@ -366,7 +371,7 @@ namespace CryptoExchange.Net.Authentication
             {
 #if NETSTANDARD2_1_OR_GREATER
                 // Read from pem private key
-                var key = _credentials.Secret!.GetString()
+                var key = _credentials.Secret!
                         .Replace("\n", "")
                         .Replace("-----BEGIN PRIVATE KEY-----", "")
                         .Replace("-----END PRIVATE KEY-----", "")
@@ -381,7 +386,7 @@ namespace CryptoExchange.Net.Authentication
             else if (_credentials.CredentialType == ApiCredentialsType.RsaXml)
             {
                 // Read from xml private key format
-                rsa.FromXmlString(_credentials.Secret!.GetString());
+                rsa.FromXmlString(_credentials.Secret!);
             }
             else
             {
@@ -447,12 +452,6 @@ namespace CryptoExchange.Net.Authentication
             else
                 return serializer.Serialize(parameters);
         }
-
-        /// <inheritdoc />
-        public void Dispose()
-        {
-            _credentials?.Dispose();
-        }
     }
 
     /// <inheritdoc />

CryptoExchange.Net/Clients/BaseApiClient.cs

@@ -1,7 +1,9 @@
 using System;
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.SharedApis;
 using Microsoft.Extensions.Logging;
 
 namespace CryptoExchange.Net.Clients
@@ -65,10 +67,7 @@ namespace CryptoExchange.Net.Clients
             BaseAddress = baseAddress;
 
             if (apiCredentials != null)
-            {
-                AuthenticationProvider?.Dispose();
                 AuthenticationProvider = CreateAuthenticationProvider(apiCredentials.Copy());
-            }
         }
 
         /// <summary>
@@ -79,16 +78,13 @@ namespace CryptoExchange.Net.Clients
         protected abstract AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials);
 
         /// <inheritdoc />
-        public abstract string FormatSymbol(string baseAsset, string quoteAsset);
+        public abstract string FormatSymbol(string baseAsset, string quoteAsset, TradingMode tradingMode, DateTime? deliverDate = null);
 
         /// <inheritdoc />
         public void SetApiCredentials<T>(T credentials) where T : ApiCredentials
         {
             if (credentials != null)
-            {
-                AuthenticationProvider?.Dispose();
                 AuthenticationProvider = CreateAuthenticationProvider(credentials.Copy());
-            }
         }
 
         /// <summary>
@@ -97,7 +93,6 @@ namespace CryptoExchange.Net.Clients
         public virtual void Dispose()
         {
             _disposing = true;
-            AuthenticationProvider?.Dispose();
         }
     }
 }

CryptoExchange.Net/Clients/BaseClient.cs

@@ -12,6 +12,28 @@ namespace CryptoExchange.Net.Clients
     /// </summary>
     public abstract class BaseClient : IDisposable
     {
+        /// <summary>
+        /// Version of the CryptoExchange.Net base library
+        /// </summary>
+        public Version CryptoExchangeLibVersion { get; } = typeof(BaseClient).Assembly.GetName().Version;
+
+        /// <summary>
+        /// Version of the client implementation
+        /// </summary>
+        public Version ExchangeLibVersion
+        { 
+            get
+            {
+               lock(_versionLock)
+                {
+                    if (_exchangeVersion == null)
+                        _exchangeVersion = GetType().Assembly.GetName().Version;
+
+                    return _exchangeVersion;
+                }
+            }
+        }
+
         /// <summary>
         /// The name of the API the client is for
         /// </summary>
@@ -27,6 +49,9 @@ namespace CryptoExchange.Net.Clients
         /// </summary>
         protected internal ILogger _logger;
 
+        private object _versionLock = new object();
+        private Version _exchangeVersion;
+
         /// <summary>
         /// Provided client options
         /// </summary>
@@ -57,7 +82,7 @@ namespace CryptoExchange.Net.Clients
                 throw new ArgumentNullException(nameof(options));
 
             ClientOptions = options;
-            _logger.Log(LogLevel.Trace, $"Client configuration: {options}, CryptoExchange.Net: v{typeof(BaseClient).Assembly.GetName().Version}, {Exchange}.Net: v{GetType().Assembly.GetName().Version}");
+            _logger.Log(LogLevel.Trace, $"Client configuration: {options}, CryptoExchange.Net: v{CryptoExchangeLibVersion}, {Exchange}.Net: v{ExchangeLibVersion}");
         }
 
         /// <summary>

CryptoExchange.Net/Clients/RestApiClient.cs

@@ -18,7 +18,6 @@ using CryptoExchange.Net.RateLimiting;
 using CryptoExchange.Net.RateLimiting.Interfaces;
 using CryptoExchange.Net.Requests;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
 
 namespace CryptoExchange.Net.Clients
 {
@@ -196,36 +195,40 @@ namespace CryptoExchange.Net.Clients
             Dictionary<string, string>? additionalHeaders = null,
             int? weight = null) where T : class
         {
-            var key = baseAddress + definition + uriParameters?.ToFormData();
+            string? cacheKey = null;
             if (ShouldCache(definition))
             {
-                _logger.CheckingCache(key);
-                var cachedValue = _cache.Get(key, ClientOptions.CachingMaxAge);
+                cacheKey = baseAddress + definition + uriParameters?.ToFormData();
+                _logger.CheckingCache(cacheKey);
+                var cachedValue = _cache.Get(cacheKey, ClientOptions.CachingMaxAge);
                 if (cachedValue != null)
                 {
-                    _logger.CacheHit(key);
+                    _logger.CacheHit(cacheKey);
                     var original = (WebCallResult<T>)cachedValue;
                     return original.Cached();
                 }
 
-                _logger.CacheNotHit(key);
+                _logger.CacheNotHit(cacheKey);
             }
 
             int currentTry = 0;
             while (true)
             {
                 currentTry++;
-                var prepareResult = await PrepareAsync(baseAddress, definition, cancellationToken, additionalHeaders, weight).ConfigureAwait(false);
+                var requestId = ExchangeHelpers.NextId();
+
+                var prepareResult = await PrepareAsync(requestId, baseAddress, definition, cancellationToken, additionalHeaders, weight).ConfigureAwait(false);
                 if (!prepareResult)
                     return new WebCallResult<T>(prepareResult.Error!);
 
                 var request = CreateRequest(
+                    requestId,
                     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)}]")));
+                _logger.RestApiSendRequest(request.RequestId, definition, request.Content, string.IsNullOrEmpty(request.Uri.Query) ? "-" : request.Uri.Query, string.Join(", ", request.GetHeaders().Select(h => h.Key + $"=[{string.Join(",", h.Value)}]")));
                 TotalRequestsMade++;
                 var result = await GetResponseAsync<T>(request, definition.RateLimitGate, cancellationToken).ConfigureAwait(false);
                 if (!result)
@@ -239,7 +242,7 @@ namespace CryptoExchange.Net.Clients
                 if (result.Success &&
                     ShouldCache(definition))
                 {
-                    _cache.Add(key, result);
+                    _cache.Add(cacheKey!, result);
                 }
 
                 return result;
@@ -249,6 +252,7 @@ namespace CryptoExchange.Net.Clients
         /// <summary>
         /// Prepare before sending a request. Sync time between client and server and check rate limits
         /// </summary>
+        /// <param name="requestId">Request id</param>
         /// <param name="baseAddress">Host and schema</param>
         /// <param name="definition">Request definition</param>
         /// <param name="cancellationToken">Cancellation token</param>
@@ -257,13 +261,13 @@ namespace CryptoExchange.Net.Clients
         /// <returns></returns>
         /// <exception cref="Exception"></exception>
         protected virtual async Task<CallResult> PrepareAsync(
+            int requestId,
             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
@@ -305,14 +309,14 @@ namespace CryptoExchange.Net.Clients
             }
 
             // Endpoint specific rate limiting
-            if (definition.EndpointLimitCount != null && definition.EndpointLimitPeriod != null)
+            if (definition.LimitGuard != null && ClientOptions.RateLimiterEnabled)
             {
                 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);
+                    var limitResult = await definition.RateLimitGate.ProcessSingleAsync(_logger, requestId, definition.LimitGuard, RateLimitItemType.Request, definition, baseAddress, AuthenticationProvider?._credentials.Key, ClientOptions.RateLimitingBehaviour, cancellationToken).ConfigureAwait(false);
                     if (!limitResult)
                         return new CallResult(limitResult.Error!);
                 }
@@ -324,6 +328,7 @@ namespace CryptoExchange.Net.Clients
         /// <summary>
         /// Creates a request object
         /// </summary>
+        /// <param name="requestId">Id of the request</param>
         /// <param name="baseAddress">Host and schema</param>
         /// <param name="definition">Request definition</param>
         /// <param name="uriParameters">The query parameters of the request</param>
@@ -331,22 +336,22 @@ namespace CryptoExchange.Net.Clients
         /// <param name="additionalHeaders">Additional headers to send with the request</param>
         /// <returns></returns>
         protected virtual IRequest CreateRequest(
+            int requestId,
             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 uriParams = uriParameters == null ? null : CreateParameterDictionary(uriParameters);
+            var bodyParams = bodyParameters == null ? null : 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>();
+            Dictionary<string, string>? headers = null;
             if (AuthenticationProvider != null)
             {
                 try
@@ -355,9 +360,9 @@ namespace CryptoExchange.Net.Clients
                         this,
                         uri,
                         definition.Method,
-                        uriParams,
-                        bodyParams,
-                        headers,
+                        ref uriParams,
+                        ref bodyParams,
+                        ref headers,
                         definition.Authenticated,
                         arraySerialization,
                         parameterPosition,
@@ -370,14 +375,18 @@ namespace CryptoExchange.Net.Clients
                 }
             }
 
-            // 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);
+            // Add the auth parameters to the uri, start with a new URI to be able to sort the parameters including the auth parameters
+            if (uriParams != null)
+                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 (headers != null)
+            {
+                foreach (var header in headers)
+                    request.AddHeader(header.Key, header.Value);
+            }
 
             if (additionalHeaders != null)
             {
@@ -398,7 +407,7 @@ namespace CryptoExchange.Net.Clients
             if (parameterPosition == HttpMethodParameterPosition.InBody)
             {
                 var contentType = bodyFormat == RequestBodyFormat.Json ? Constants.JsonContentHeader : Constants.FormContentHeader;
-                if (bodyParams.Count != 0)
+                if (bodyParams != null && bodyParams.Count != 0)
                     WriteParamBody(request, bodyParams, contentType);
                 else
                     request.SetContent(RequestBodyEmptyContent, contentType);
@@ -668,47 +677,47 @@ namespace CryptoExchange.Net.Clients
                     if (error.Code == null || error.Code == 0)
                         error.Code = (int)response.StatusCode;
 
-                    return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, error!);
+                    return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error!);
                 }
 
                 if (typeof(T) == typeof(object))
                     // Success status code and expected empty response, assume it's correct
-                    return new WebCallResult<T>(statusCode, headers, sw.Elapsed, 0, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, null);
+                    return new WebCallResult<T>(statusCode, headers, sw.Elapsed, 0, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, null);
 
                 var valid = await accessor.Read(responseStream, outputOriginalData).ConfigureAwait(false);
                 if (!valid)
                 {
                     // Invalid json
                     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);
+                    return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
                 }
 
                 // Json response received
                 var parsedError = TryParseError(accessor);
                 if (parsedError != null)
                     // Success status code, but TryParseError determined it was an error response
-                    return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, parsedError);
+                    return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, parsedError);
 
                 var deserializeResult = accessor.Deserialize<T>();
-                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(), deserializeResult.Data, deserializeResult.Error);
+                return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, deserializeResult.Data, deserializeResult.Error);
             }
             catch (HttpRequestException requestException)
             {
                 // Request exception, can't reach server for instance
                 var exceptionInfo = requestException.ToLogString();
-                return new WebCallResult<T>(null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, new WebError(exceptionInfo));
+                return new WebCallResult<T>(null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, new WebError(exceptionInfo));
             }
             catch (OperationCanceledException canceledException)
             {
                 if (cancellationToken != default && canceledException.CancellationToken == cancellationToken)
                 {
                     // Cancellation token canceled by caller
-                    return new WebCallResult<T>(null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, new CancellationRequestedError());
+                    return new WebCallResult<T>(null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, new CancellationRequestedError());
                 }
                 else
                 {
                     // Request timed out
-                    return new WebCallResult<T>(null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), default, new WebError($"Request timed out"));
+                    return new WebCallResult<T>(null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, new WebError($"Request timed out"));
                 }
             }
             finally
@@ -802,8 +811,8 @@ namespace CryptoExchange.Net.Clients
             }
 
             var headers = new Dictionary<string, string>();
-            var uriParameters = parameterPosition == HttpMethodParameterPosition.InUri ? CreateParameterDictionary(parameters) : new Dictionary<string, object>();
-            var bodyParameters = parameterPosition == HttpMethodParameterPosition.InBody ? CreateParameterDictionary(parameters) : new Dictionary<string, object>();
+            var uriParameters = parameterPosition == HttpMethodParameterPosition.InUri ? CreateParameterDictionary(parameters) : null;
+            var bodyParameters = parameterPosition == HttpMethodParameterPosition.InBody ? CreateParameterDictionary(parameters) : null;
             if (AuthenticationProvider != null)
             {
                 try
@@ -812,9 +821,9 @@ namespace CryptoExchange.Net.Clients
                         this,
                         uri,
                         method,
-                        uriParameters,
-                        bodyParameters,
-                        headers,
+                        ref uriParameters,
+                        ref bodyParameters,
+                        ref headers,
                         signed,
                         arraySerialization,
                         parameterPosition,
@@ -827,24 +836,18 @@ namespace CryptoExchange.Net.Clients
                 }
             }
 
-            // Sanity check
-            foreach (var param in parameters)
-            {
-                if (!uriParameters.ContainsKey(param.Key) && !bodyParameters.ContainsKey(param.Key))
-                {
-                    throw new Exception($"Missing parameter {param.Key} after authentication processing. AuthenticationProvider implementation " +
-                        $"should return provided parameters in either the uri or body parameters output");
-                }
-            }
-
             // Add the auth parameters to the uri, start with a new URI to be able to sort the parameters including the auth parameters            
-            uri = uri.SetParameters(uriParameters, arraySerialization);
+            if (uriParameters != null)
+                uri = uri.SetParameters(uriParameters, arraySerialization);
 
             var request = RequestFactory.Create(method, uri, requestId);
             request.Accept = Constants.JsonContentHeader;
 
-            foreach (var header in headers)
-                request.AddHeader(header.Key, header.Value);
+            if (headers != null)
+            {
+                foreach (var header in headers)
+                    request.AddHeader(header.Key, header.Value);
+            }
 
             if (additionalHeaders != null)
             {
@@ -865,7 +868,7 @@ namespace CryptoExchange.Net.Clients
             if (parameterPosition == HttpMethodParameterPosition.InBody)
             {
                 var contentType = bodyFormat == RequestBodyFormat.Json ? Constants.JsonContentHeader : Constants.FormContentHeader;
-                if (bodyParameters.Any())
+                if (bodyParameters?.Any() == true)
                     WriteParamBody(request, bodyParameters, contentType);
                 else
                     request.SetContent(RequestBodyEmptyContent, contentType);
@@ -962,14 +965,14 @@ namespace CryptoExchange.Net.Clients
         {
             var timeSyncParams = GetTimeSyncInfo();
             if (timeSyncParams == null)
-                return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, true, null);
+                return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
 
             if (await timeSyncParams.TimeSyncState.Semaphore.WaitAsync(0).ConfigureAwait(false))
             {
                 if (!timeSyncParams.SyncTime || DateTime.UtcNow - timeSyncParams.TimeSyncState.LastSyncTime < timeSyncParams.RecalculationInterval)
                 {
                     timeSyncParams.TimeSyncState.Semaphore.Release();
-                    return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, true, null);
+                    return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
                 }
 
                 var localTime = DateTime.UtcNow;
@@ -998,7 +1001,7 @@ namespace CryptoExchange.Net.Clients
                 timeSyncParams.TimeSyncState.Semaphore.Release();
             }
 
-            return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, true, null);
+            return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
         }
 
         private bool ShouldCache(RequestDefinition definition)

CryptoExchange.Net/Clients/SocketApiClient.cs

@@ -8,7 +8,6 @@ using CryptoExchange.Net.RateLimiting.Interfaces;
 using CryptoExchange.Net.Sockets;
 using Microsoft.Extensions.Logging;
 using System;
-using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
@@ -189,7 +188,10 @@ namespace CryptoExchange.Net.Clients
                 return new CallResult<UpdateSubscription>(new InvalidOperationError("Client disposed, can't subscribe"));
 
             if (subscription.Authenticated && AuthenticationProvider == null)
+            {
+                _logger.LogWarning("Failed to subscribe, private subscription but no API credentials set");
                 return new CallResult<UpdateSubscription>(new NoApiCredentialsError());
+            }
 
             SocketConnection socketConnection;
             var released = false;
@@ -251,7 +253,7 @@ namespace CryptoExchange.Net.Clients
                 return new CallResult<UpdateSubscription>(new ServerError("Socket is paused"));
             }
 
-            var waitEvent = new ManualResetEvent(false);
+            var waitEvent = new AsyncResetEvent(false);
             var subQuery = subscription.GetSubQuery(socketConnection);
             if (subQuery != null)
             {
@@ -269,7 +271,7 @@ namespace CryptoExchange.Net.Clients
                     {
                         _logger.FailedToSubscribe(socketConnection.SocketId, subResult.Error?.ToString());
                         // If this was a timeout we still need to send an unsubscribe to prevent messages coming in later
-                        await socketConnection.CloseAsync(subscription, isTimeout).ConfigureAwait(false);
+                        await socketConnection.CloseAsync(subscription).ConfigureAwait(false);
                         return new CallResult<UpdateSubscription>(subResult.Error!);
                     }
                 }
@@ -516,6 +518,7 @@ namespace CryptoExchange.Net.Clients
             var socket = CreateSocket(connectionAddress.Data!);
             var socketConnection = new SocketConnection(_logger, this, socket, address);
             socketConnection.UnhandledMessage += HandleUnhandledMessage;
+            socketConnection.ConnectRateLimitedAsync += HandleConnectRateLimitedAsync;
             socketConnection.DedicatedRequestConnection = dedicatedRequestConnection;
 
             foreach (var ptg in PeriodicTaskRegistrations)
@@ -535,6 +538,19 @@ namespace CryptoExchange.Net.Clients
         {
         }
 
+        /// <summary>
+        /// Process connect rate limited
+        /// </summary>
+        protected async virtual Task HandleConnectRateLimitedAsync()
+        {
+            if (ClientOptions.RateLimiterEnabled && RateLimiter is not null && ClientOptions.ConnectDelayAfterRateLimited is not null)
+            {
+                var retryAfter = DateTime.UtcNow.Add(ClientOptions.ConnectDelayAfterRateLimited.Value);
+                _logger.AddingRetryAfterGuard(retryAfter);
+                await RateLimiter.SetRetryAfterGuardAsync(retryAfter, RateLimiting.RateLimitItemType.Connection).ConfigureAwait(false);
+            }
+        }
+
         /// <summary>
         /// Connect a socket
         /// </summary>
@@ -786,9 +802,10 @@ namespace CryptoExchange.Net.Clients
         /// <summary>
         /// Preprocess a stream message
         /// </summary>
+        /// <param name="connection"></param>
         /// <param name="type"></param>
         /// <param name="data"></param>
         /// <returns></returns>
-        public virtual ReadOnlyMemory<byte> PreprocessStreamMessage(WebSocketMessageType type, ReadOnlyMemory<byte> data) => data;
+        public virtual ReadOnlyMemory<byte> PreprocessStreamMessage(SocketConnection connection, WebSocketMessageType type, ReadOnlyMemory<byte> data) => data;
     }
 }

CryptoExchange.Net/Converters/JsonNet/BigDecimalConverter.cs

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

CryptoExchange.Net/Converters/JsonNet/DateTimeConverter.cs

@@ -1,5 +1,4 @@
-using Microsoft.Extensions.Primitives;
-using Newtonsoft.Json;
+using Newtonsoft.Json;
 using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;

CryptoExchange.Net/Converters/SystemTextJson/ArrayConverter.cs

@@ -32,6 +32,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             public ArrayPropertyAttribute ArrayProperty { get; set; } = null!;
             public Type? JsonConverterType { get; set; }
             public bool DefaultDeserialization { get; set; }
+            public Type TargetType { get; set; } = null!;
         }
 
         private class ArrayConverterInner<T> : JsonConverter<T>
@@ -70,7 +71,8 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                         ArrayProperty = att,
                         PropertyInfo = property,
                         DefaultDeserialization = property.GetCustomAttribute<JsonConversionAttribute>() != null,
-                        JsonConverterType = property.GetCustomAttribute<JsonConverterAttribute>()?.ConverterType
+                        JsonConverterType = property.GetCustomAttribute<JsonConverterAttribute>()?.ConverterType,
+                        TargetType = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType
                     });
                 }
 
@@ -94,10 +96,12 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 
                     var attribute = attributes.SingleOrDefault(a => a.ArrayProperty.Index == index);
                     if (attribute == null)
+                    {
+                        index++;
                         continue;
+                    }
 
-                    var targetType = attribute.PropertyInfo.PropertyType;
-
+                    var targetType = attribute.TargetType;
                     object? value = null;
                     if (attribute.JsonConverterType != null)
                     {
@@ -124,7 +128,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                         };
                     }
 
-                    attribute.PropertyInfo.SetValue(result, value == null ? null : Convert.ChangeType(value, attribute.PropertyInfo.PropertyType, CultureInfo.InvariantCulture));
+                    attribute.PropertyInfo.SetValue(result, value == null ? null : Convert.ChangeType(value, targetType, CultureInfo.InvariantCulture));
                     
                     index++;
                 }

CryptoExchange.Net/Converters/SystemTextJson/BigDecimalConverter.cs

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

CryptoExchange.Net/Converters/SystemTextJson/DateTimeConverter.cs

@@ -1,5 +1,4 @@
-using Microsoft.Extensions.Primitives;
-using System;
+using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
@@ -58,6 +57,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                     var stringValue = reader.GetString();
                     if (string.IsNullOrWhiteSpace(stringValue)
                         || stringValue == "-1"
+                        || stringValue == "0001-01-01T00:00:00Z"
                         || double.TryParse(stringValue, out var doubleVal) && doubleVal == 0)
                     {
                         return default;

CryptoExchange.Net/Converters/SystemTextJson/DecimalConverter.cs

@@ -19,13 +19,29 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             if (reader.TokenType == JsonTokenType.String)
             {
                 var value = reader.GetString();
-                if (string.IsNullOrEmpty(value))
+                if (string.IsNullOrEmpty(value) || string.Equals("null", value))
                     return null;
 
-                return decimal.Parse(value, NumberStyles.Float, CultureInfo.InvariantCulture);
+                try
+                {
+                    return decimal.Parse(value, NumberStyles.Float, CultureInfo.InvariantCulture);
+                }
+                catch(OverflowException)
+                {
+                    // Value doesn't fit decimal, default to max value
+                    return decimal.MaxValue;
+                }
             }
 
-            return reader.GetDecimal();
+            try
+            {
+                return reader.GetDecimal();
+            }
+            catch(FormatException)
+            {
+                // Format issue, assume value is too large
+                return decimal.MaxValue;
+            }
         }
 
         /// <inheritdoc />

CryptoExchange.Net/Converters/SystemTextJson/EnumConverter.cs

@@ -211,5 +211,37 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 
             return enumValue == null ? null : (mapping.FirstOrDefault(v => v.Key.Equals(enumValue)).Value ?? enumValue.ToString());
         }
+
+        /// <summary>
+        /// Get the enum value from a string
+        /// </summary>
+        /// <typeparam name="T">Enum type</typeparam>
+        /// <param name="value">String value</param>
+        /// <returns></returns>
+        public static T? ParseString<T>(string value) where T : Enum
+        {
+            var type = typeof(T);
+            if (!_mapping.TryGetValue(type, out var enumMapping))
+                enumMapping = AddMapping(type);
+
+            var mapping = enumMapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCulture));
+            if (mapping.Equals(default(KeyValuePair<object, string>)))
+                mapping = enumMapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCultureIgnoreCase));
+
+            if (!mapping.Equals(default(KeyValuePair<object, string>)))
+            {
+                return (T)mapping.Key;
+            }
+
+            try
+            {
+                // If no explicit mapping is found try to parse string
+                return (T)Enum.Parse(type, value, true);
+            }
+            catch (Exception)
+            {
+                return default;
+            }
+        }
     }
 }

CryptoExchange.Net/Converters/SystemTextJson/IntConverter.cs

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

CryptoExchange.Net/Converters/SystemTextJson/LongConverter.cs

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

CryptoExchange.Net/Converters/SystemTextJson/NumberStringConverter.cs

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

CryptoExchange.Net/Converters/SystemTextJson/ObjectStringConverter.cs

@@ -1,11 +1,6 @@
 using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Runtime.Serialization;
-using System.Text;
 using System.Text.Json.Serialization;
 using System.Text.Json;
-using System.Globalization;
 
 namespace CryptoExchange.Net.Converters.SystemTextJson
 {
@@ -25,7 +20,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             if (string.IsNullOrEmpty(value))
                 return default;
 
-            return (T?)JsonDocument.Parse(value).Deserialize(typeof(T));
+            return (T?)JsonDocument.Parse(value!).Deserialize(typeof(T));
         }
 
         /// <inheritdoc />

CryptoExchange.Net/Converters/SystemTextJson/SerializerOptions.cs

@@ -21,6 +21,8 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                         new EnumConverter(),
                         new BoolConverter(),
                         new DecimalConverter(),
+                        new IntConverter(),
+                        new LongConverter()
                     }
         };
     }

CryptoExchange.Net/Converters/SystemTextJson/SystemTextJsonMessageAccessor.cs

@@ -123,6 +123,12 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             if (value.Value.ValueKind == JsonValueKind.Object || value.Value.ValueKind == JsonValueKind.Array)
                 return default;
 
+            if (typeof(T) == typeof(string))
+            {
+                if (value.Value.ValueKind == JsonValueKind.Number)
+                    return (T)(object)value.Value.GetInt64().ToString();
+            }
+
             return value.Value.Deserialize<T>();
         }
 
@@ -242,6 +248,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         {
             _stream?.Dispose();
             _stream = null;
+            _document?.Dispose();
             _document = null;
         }
 
@@ -261,6 +268,14 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 
             try
             {
+                var firstByte = data.Span[0];
+                if (firstByte != 0x7b && firstByte != 0x5b)
+                {
+                    // Value doesn't start with `{` or `[`, prevent deserialization attempt as it's slow
+                    IsJson = false;
+                    return new CallResult(new ServerError("Not a json value"));
+                }
+
                 _document = JsonDocument.Parse(data);
                 IsJson = true;
                 return new CallResult(null);
@@ -289,6 +304,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         public override void Clear()
         {
             _bytes = null;
+            _document?.Dispose();
             _document = null;
         }
     }

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.7.0</PackageVersion>
-    <AssemblyVersion>7.7.0</AssemblyVersion>
-    <FileVersion>7.7.0</FileVersion>
+    <PackageVersion>8.0.1</PackageVersion>
+    <AssemblyVersion>8.0.1</AssemblyVersion>
+    <FileVersion>8.0.1</FileVersion>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>OKX;OKX.Net;Mexc;Mexc.Net;Kucoin;Kucoin.Net;Kraken;Kraken.Net;Huobi;Huobi.Net;CoinEx;CoinEx.Net;Bybit;Bybit.Net;Bitget;Bitget.Net;Bitfinex;Bitfinex.Net;Binance;Binance.Net;CryptoCurrency;CryptoCurrency Exchange</PackageTags>
     <RepositoryType>git</RepositoryType>
@@ -35,7 +35,7 @@
     <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
   </PropertyGroup>
   <ItemGroup Label="Deterministic Build" Condition="'$(Configuration)' == 'Release'">
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0">
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
@@ -58,6 +58,6 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="8.0.1" />
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.1" />
-    <PackageReference Include="System.Text.Json" Version="8.0.3" />
+    <PackageReference Include="System.Text.Json" Version="8.0.4" />
   </ItemGroup>
 </Project>

CryptoExchange.Net/ExchangeHelpers.cs

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

CryptoExchange.Net/ExtensionMethods.cs

@@ -4,11 +4,12 @@ using System.IO.Compression;
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
-using System.Security;
 using System.Text;
 using System.Web;
 using CryptoExchange.Net.Objects;
 using System.Globalization;
+using Microsoft.Extensions.DependencyInjection;
+using CryptoExchange.Net.SharedApis;
 
 namespace CryptoExchange.Net
 {
@@ -113,92 +114,6 @@ namespace CryptoExchange.Net
             return formData.ToString();
         }
 
-        /// <summary>
-        /// Get the string the secure string is representing
-        /// </summary>
-        /// <param name="source">The source secure string</param>
-        /// <returns></returns>
-        public static string GetString(this SecureString source)
-        {
-            lock (source)
-            {
-                string result;
-                var length = source.Length;
-                var pointer = IntPtr.Zero;
-                var chars = new char[length];
-
-                try
-                {
-                    pointer = Marshal.SecureStringToBSTR(source);
-                    Marshal.Copy(pointer, chars, 0, length);
-
-                    result = string.Join("", chars);
-                }
-                finally
-                {
-                    if (pointer != IntPtr.Zero)
-                    {
-                        Marshal.ZeroFreeBSTR(pointer);
-                    }
-                }
-
-                return result;
-            }
-        }
-
-        /// <summary>
-        /// Are 2 secure strings equal
-        /// </summary>
-        /// <param name="ss1">Source secure string</param>
-        /// <param name="ss2">Compare secure string</param>
-        /// <returns>True if equal by value</returns>
-        public static bool IsEqualTo(this SecureString ss1, SecureString ss2)
-        {
-            IntPtr bstr1 = IntPtr.Zero;
-            IntPtr bstr2 = IntPtr.Zero;
-            try
-            {
-                bstr1 = Marshal.SecureStringToBSTR(ss1);
-                bstr2 = Marshal.SecureStringToBSTR(ss2);
-                int length1 = Marshal.ReadInt32(bstr1, -4);
-                int length2 = Marshal.ReadInt32(bstr2, -4);
-                if (length1 == length2)
-                {
-                    for (int x = 0; x < length1; ++x)
-                    {
-                        byte b1 = Marshal.ReadByte(bstr1, x);
-                        byte b2 = Marshal.ReadByte(bstr2, x);
-                        if (b1 != b2) return false;
-                    }
-                }
-                else
-                {
-                    return false;
-                }
-
-                return true;
-            }
-            finally
-            {
-                if (bstr2 != IntPtr.Zero) Marshal.ZeroFreeBSTR(bstr2);
-                if (bstr1 != IntPtr.Zero) Marshal.ZeroFreeBSTR(bstr1);
-            }
-        }
-
-        /// <summary>
-        /// Create a secure string from a string
-        /// </summary>
-        /// <param name="source"></param>
-        /// <returns></returns>
-        public static SecureString ToSecureString(this string source)
-        {
-            var secureString = new SecureString();
-            foreach (var c in source)
-                secureString.AppendChar(c);
-            secureString.MakeReadOnly();
-            return secureString;
-        }
-
         /// <summary>
         /// Validates an int is one of the allowed values
         /// </summary>
@@ -274,6 +189,16 @@ namespace CryptoExchange.Net
                 throw new ArgumentException($"No values provided for parameter {argumentName}", argumentName);
         }
 
+        /// <summary>
+        /// Format a string to RFC3339/ISO8601 string
+        /// </summary>
+        /// <param name="dateTime"></param>
+        /// <returns></returns>
+        public static string ToRfc3339String(this DateTime dateTime)
+        {
+            return dateTime.ToString("yyyy-MM-dd'T'HH:mm:ss.fffzzz", DateTimeFormatInfo.InvariantInfo);
+        }
+
         /// <summary>
         /// Format an exception and inner exception to a readable string
         /// </summary>
@@ -318,26 +243,6 @@ namespace CryptoExchange.Net
             return url.TrimEnd('/');
         }
 
-        /// <summary>
-        /// Fill parameters in a path. Parameters are specified by '{}' and should be specified in occuring sequence
-        /// </summary>
-        /// <param name="path">The total path string</param>
-        /// <param name="values">The values to fill</param>
-        /// <returns></returns>
-        public static string FillPathParameters(this string path, params string[] values)
-        {
-            foreach (var value in values)
-            {
-                var index = path.IndexOf("{}", StringComparison.Ordinal);
-                if (index >= 0)
-                {
-                    path = path.Remove(index, 2);
-                    path = path.Insert(index, value);
-                }
-            }
-            return path;
-        }
-
         /// <summary>
         /// Create a new uri with the provided parameters as query
         /// </summary>
@@ -453,7 +358,7 @@ namespace CryptoExchange.Net
         }
 
         /// <summary>
-        /// Decompress using Gzip
+        /// Decompress using GzipStream
         /// </summary>
         /// <param name="data"></param>
         /// <returns></returns>
@@ -467,6 +372,133 @@ namespace CryptoExchange.Net
             deflateStream.CopyTo(decompressedStream);
             return new ReadOnlyMemory<byte>(decompressedStream.GetBuffer(), 0, (int)decompressedStream.Length);
         }
+
+        /// <summary>
+        /// Decompress using DeflateStream
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        public static ReadOnlyMemory<byte> Decompress(this ReadOnlyMemory<byte> input)
+        {
+            var output = new MemoryStream();
+
+            using (var compressStream = new MemoryStream(input.ToArray()))
+            using (var decompressor = new DeflateStream(compressStream, CompressionMode.Decompress))
+                decompressor.CopyTo(output);
+
+            output.Position = 0;
+            return new ReadOnlyMemory<byte>(output.GetBuffer(), 0, (int)output.Length);
+        }
+
+        /// <summary>
+        /// Whether the trading mode is linear
+        /// </summary>
+        public static bool IsLinear(this TradingMode type) => type == TradingMode.PerpetualLinear || type == TradingMode.DeliveryLinear;
+
+        /// <summary>
+        /// Whether the trading mode is inverse
+        /// </summary>
+        public static bool IsInverse(this TradingMode type) => type == TradingMode.PerpetualInverse || type == TradingMode.DeliveryInverse;
+        
+        /// <summary>
+        /// Whether the trading mode is perpetual
+        /// </summary>
+        public static bool IsPerpetual(this TradingMode type) => type == TradingMode.PerpetualInverse || type == TradingMode.PerpetualLinear;
+
+        /// <summary>
+        /// Whether the trading mode is delivery
+        /// </summary>
+        public static bool IsDelivery(this TradingMode type) => type == TradingMode.DeliveryInverse || type == TradingMode.DeliveryLinear;
+
+        /// <summary>
+        /// Register rest client interfaces
+        /// </summary>
+        public static IServiceCollection RegisterSharedRestInterfaces<T>(this IServiceCollection services, Func<IServiceProvider, T> client)
+        {
+            if (typeof(IAssetsRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IAssetsRestClient)client(x)!);
+            if (typeof(IBalanceRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IBalanceRestClient)client(x)!);
+            if (typeof(IDepositRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IDepositRestClient)client(x)!);
+            if (typeof(IKlineRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IKlineRestClient)client(x)!);
+            if (typeof(IListenKeyRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IListenKeyRestClient)client(x)!);
+            if (typeof(IOrderBookRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IOrderBookRestClient)client(x)!);
+            if (typeof(IRecentTradeRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IRecentTradeRestClient)client(x)!);
+            if (typeof(ITradeHistoryRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ITradeHistoryRestClient)client(x)!);
+            if (typeof(IWithdrawalRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IWithdrawalRestClient)client(x)!);
+            if (typeof(IWithdrawRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IWithdrawRestClient)client(x)!);
+
+            if (typeof(ISpotOrderRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ISpotOrderRestClient)client(x)!);
+            if (typeof(ISpotSymbolRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ISpotSymbolRestClient)client(x)!);
+            if (typeof(ISpotTickerRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ISpotTickerRestClient)client(x)!);
+
+            if (typeof(IFundingRateRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IFundingRateRestClient)client(x)!);
+            if (typeof(IFuturesOrderRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IFuturesOrderRestClient)client(x)!);
+            if (typeof(IFuturesSymbolRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IFuturesSymbolRestClient)client(x)!);
+            if (typeof(IFuturesTickerRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IFuturesTickerRestClient)client(x)!);
+            if (typeof(IIndexPriceKlineRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IIndexPriceKlineRestClient)client(x)!);
+            if (typeof(ILeverageRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ILeverageRestClient)client(x)!);
+            if (typeof(IMarkPriceKlineRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IMarkPriceKlineRestClient)client(x)!);
+            if (typeof(IOpenInterestRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IOpenInterestRestClient)client(x)!);
+            if (typeof(IPositionHistoryRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IPositionHistoryRestClient)client(x)!);
+            if (typeof(IPositionModeRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IPositionModeRestClient)client(x)!);
+
+            return services;
+        }
+
+        /// <summary>
+        /// Register socket client interfaces
+        /// </summary>
+        public static IServiceCollection RegisterSharedSocketInterfaces<T>(this IServiceCollection services, Func<IServiceProvider, T> client)
+        {
+            if (typeof(IBalanceSocketClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IBalanceSocketClient)client(x)!);
+            if (typeof(IBookTickerSocketClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IBookTickerSocketClient)client(x)!);
+            if (typeof(IKlineSocketClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IKlineSocketClient)client(x)!);
+            if (typeof(IOrderBookRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IOrderBookRestClient)client(x)!);
+            if (typeof(ITickerSocketClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ITickerSocketClient)client(x)!);
+            if (typeof(ITickersSocketClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ITickersSocketClient)client(x)!);
+            if (typeof(ITradeSocketClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ITradeSocketClient)client(x)!);
+            if (typeof(IUserTradeSocketClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IUserTradeSocketClient)client(x)!);
+
+            if (typeof(ISpotOrderSocketClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ISpotOrderSocketClient)client(x)!);
+
+            if (typeof(IFuturesOrderSocketClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IFuturesOrderSocketClient)client(x)!);
+            if (typeof(IPositionSocketClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IPositionSocketClient)client(x)!);
+
+            return services;
+        }
     }
 }
 

CryptoExchange.Net/Interfaces/CommonClients/IBaseRestClient.cs

@@ -8,131 +8,87 @@ using System.Threading.Tasks;
 namespace CryptoExchange.Net.Interfaces.CommonClients
 {
     /// <summary>
-    /// Common rest client endpoints
+    /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
     /// </summary>
     public interface IBaseRestClient
     {
         /// <summary>
-        /// The name of the exchange
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
         string ExchangeName { get; }
 
         /// <summary>
-        /// Should be triggered on order placing
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
         event Action<OrderId> OnOrderPlaced;
         /// <summary>
-        /// Should be triggered on order cancelling
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
         event Action<OrderId> OnOrderCanceled;
 
         /// <summary>
-        /// Get the symbol name based on a base and quote asset
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="baseAsset">The base asset</param>
-        /// <param name="quoteAsset">The quote asset</param>
-        /// <returns></returns>
         string GetSymbolName(string baseAsset, string quoteAsset);
 
         /// <summary>
-        /// Get a list of symbols for the exchange
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns></returns>
         Task<WebCallResult<IEnumerable<Symbol>>> GetSymbolsAsync(CancellationToken ct = default);
 
         /// <summary>
-        /// Get a ticker for the exchange
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="symbol">The symbol to get klines for</param>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns></returns>
         Task<WebCallResult<Ticker>> GetTickerAsync(string symbol, CancellationToken ct = default);
 
         /// <summary>
-        /// Get a list of tickers for the exchange
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns></returns>
         Task<WebCallResult<IEnumerable<Ticker>>> GetTickersAsync(CancellationToken ct = default);
 
         /// <summary>
-        /// Get a list of candles for a given symbol on the exchange
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="symbol">The symbol to retrieve the candles for</param>
-        /// <param name="timespan">The timespan to retrieve the candles for. The supported value are dependent on the exchange</param>
-        /// <param name="startTime">[Optional] Start time to retrieve klines for</param>
-        /// <param name="endTime">[Optional] End time to retrieve klines for</param>
-        /// <param name="limit">[Optional] Max number of results</param>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns></returns>
         Task<WebCallResult<IEnumerable<Kline>>> GetKlinesAsync(string symbol, TimeSpan timespan, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, CancellationToken ct = default);
 
         /// <summary>
-        /// Get the order book for a symbol
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="symbol">The symbol to get the book for</param>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns></returns>
         Task<WebCallResult<CommonObjects.OrderBook>> GetOrderBookAsync(string symbol, CancellationToken ct = default);
 
         /// <summary>
-        /// The recent trades for a symbol
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="symbol">The symbol to get the trades for</param>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns></returns>
         Task<WebCallResult<IEnumerable<Trade>>> GetRecentTradesAsync(string symbol, CancellationToken ct = default);
 
         /// <summary>
-        /// Get balances
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="accountId">[Optional] The account id to retrieve balances for, required for some exchanges, ignored otherwise</param>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns></returns>
         Task<WebCallResult<IEnumerable<Balance>>> GetBalancesAsync(string? accountId = null, CancellationToken ct = default);
 
         /// <summary>
-        /// Get an order by id
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="orderId">The id</param>
-        /// <param name="symbol">[Optional] The symbol the order is on, required for some exchanges, ignored otherwise</param>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns></returns>
         Task<WebCallResult<Order>> GetOrderAsync(string orderId, string? symbol = null, CancellationToken ct = default);
 
         /// <summary>
-        /// Get trades for an order by id
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="orderId">The id</param>
-        /// <param name="symbol">[Optional] The symbol the order is on, required for some exchanges, ignored otherwise</param>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns></returns>
         Task<WebCallResult<IEnumerable<UserTrade>>> GetOrderTradesAsync(string orderId, string? symbol = null, CancellationToken ct = default);
 
         /// <summary>
-        /// Get a list of open orders
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="symbol">[Optional] The symbol to get open orders for, required for some exchanges, ignored otherwise</param>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns></returns>
         Task<WebCallResult<IEnumerable<Order>>> GetOpenOrdersAsync(string? symbol = null, CancellationToken ct = default);
 
         /// <summary>
-        /// Get a list of closed orders
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="symbol">[Optional] The symbol to get closed orders for, required for some exchanges, ignored otherwise</param>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns></returns>
         Task<WebCallResult<IEnumerable<Order>>> GetClosedOrdersAsync(string? symbol = null, CancellationToken ct = default);
 
         /// <summary>
-        /// Cancel an order by id
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="orderId">The id</param>
-        /// <param name="symbol">[Optional] The symbol the order is on, required for some exchanges, ignored otherwise</param>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns></returns>
         Task<WebCallResult<OrderId>> CancelOrderAsync(string orderId, string? symbol = null, CancellationToken ct = default);
     }
 }

CryptoExchange.Net/Interfaces/CommonClients/IFuturesClient.cs

@@ -7,30 +7,18 @@ using CryptoExchange.Net.Objects;
 namespace CryptoExchange.Net.Interfaces.CommonClients
 {
     /// <summary>
-    /// Common futures endpoints
+    /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
     /// </summary>
     public interface IFuturesClient : IBaseRestClient
     {
         /// <summary>
-        /// Place an order
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="symbol">The symbol the order is for</param>
-        /// <param name="side">The side of the order</param>
-        /// <param name="type">The type of the order</param>
-        /// <param name="quantity">The quantity of the order</param>
-        /// <param name="price">The price of the order, only for limit orders</param>
-        /// <param name="accountId">[Optional] The account id to place the order on, required for some exchanges, ignored otherwise</param>
-        /// <param name="leverage">[Optional] Leverage for this order. This is needed for some exchanges. For exchanges where this is not needed this parameter is ignored (and should be set before hand)</param>
-        /// <param name="clientOrderId">[Optional] Client specified id for this order</param>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns>The id of the resulting order</returns>
         Task<WebCallResult<OrderId>> PlaceOrderAsync(string symbol, CommonOrderSide side, CommonOrderType type, decimal quantity, decimal? price = null, int? leverage = null, string? accountId = null, string? clientOrderId = null, CancellationToken ct = default);
 
         /// <summary>
-        /// Get position
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns></returns>
         Task<WebCallResult<IEnumerable<Position>>> GetPositionsAsync(CancellationToken ct = default);
     }
 }

CryptoExchange.Net/Interfaces/CommonClients/ISpotClient.cs

@@ -6,22 +6,13 @@ using System.Threading.Tasks;
 namespace CryptoExchange.Net.Interfaces.CommonClients
 {
     /// <summary>
-    /// Common spot endpoints
+    /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="" /> for more info.
     /// </summary>
     public interface ISpotClient: IBaseRestClient
     {
         /// <summary>
-        /// Place an order
+        /// DEPRECATED; use <see cref="SharedApis.ISharedClient" /> instead for common/shared functionality. See <see href="https://jkorf.github.io/CryptoExchange.Net/docs/index.html#shared" /> for more info.
         /// </summary>
-        /// <param name="symbol">The symbol the order is for</param>
-        /// <param name="side">The side of the order</param>
-        /// <param name="type">The type of the order</param>
-        /// <param name="quantity">The quantity of the order</param>
-        /// <param name="price">The price of the order, only for limit orders</param>
-        /// <param name="accountId">[Optional] The account id to place the order on, required for some exchanges, ignored otherwise</param>
-        /// <param name="clientOrderId">[Optional] Client specified id for this order</param>
-        /// <param name="ct">[Optional] Cancellation token for cancelling the request</param>
-        /// <returns>The id of the resulting order</returns>
         Task<WebCallResult<OrderId>> PlaceOrderAsync(string symbol, CommonOrderSide side, CommonOrderType type, decimal quantity, decimal? price = null, string? accountId = null, string? clientOrderId = null, CancellationToken ct = default);
     }
 }

CryptoExchange.Net/Interfaces/IBaseApiClient.cs

@@ -1,4 +1,7 @@
 using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.SharedApis;
+using System;
 
 namespace CryptoExchange.Net.Interfaces
 {
@@ -17,8 +20,10 @@ namespace CryptoExchange.Net.Interfaces
         /// </summary>
         /// <param name="baseAsset">The base asset</param>
         /// <param name="quoteAsset">The quote asset</param>
+        /// <param name="tradingMode">The trading mode</param>
+        /// <param name="deliverDate">The deliver date for a delivery futures symbol</param>
         /// <returns></returns>
-        string FormatSymbol(string baseAsset, string quoteAsset);
+        string FormatSymbol(string baseAsset, string quoteAsset, TradingMode tradingMode, DateTime? deliverDate = null);
 
         /// <summary>
         /// Set the API credentials for this API client

CryptoExchange.Net/Interfaces/IMessageProcessor.cs

@@ -3,6 +3,7 @@ using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.Sockets;
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace CryptoExchange.Net.Interfaces
 {
@@ -25,7 +26,7 @@ namespace CryptoExchange.Net.Interfaces
         /// <param name="connection"></param>
         /// <param name="message"></param>
         /// <returns></returns>
-        CallResult Handle(SocketConnection connection, DataEvent<object> message);
+        Task<CallResult> Handle(SocketConnection connection, DataEvent<object> message);
         /// <summary>
         /// Get the type the message should be deserialized to
         /// </summary>

CryptoExchange.Net/Interfaces/IRateLimiter.cs

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

CryptoExchange.Net/Interfaces/IWebsocket.cs

@@ -17,7 +17,7 @@ namespace CryptoExchange.Net.Interfaces
         /// <summary>
         /// Websocket message received event
         /// </summary>
-        event Action<WebSocketMessageType, ReadOnlyMemory<byte>> OnStreamMessage;
+        event Func<WebSocketMessageType, ReadOnlyMemory<byte>, Task> OnStreamMessage;
         /// <summary>
         /// Websocket sent event, RequestId as parameter
         /// </summary>
@@ -27,6 +27,10 @@ namespace CryptoExchange.Net.Interfaces
         /// </summary>
         event Func<int, Task>? OnRequestRateLimited;
         /// <summary>
+        /// Connection was ratelimited and couldn't be established
+        /// </summary>
+        event Func<Task>? OnConnectRateLimited;
+        /// <summary>
         /// Websocket error event
         /// </summary>
         event Func<Exception, Task> OnError;
@@ -78,7 +82,7 @@ namespace CryptoExchange.Net.Interfaces
         /// <param name="id"></param>
         /// <param name="data"></param>
         /// <param name="weight"></param>
-        void Send(int id, string data, int weight);
+        bool Send(int id, string data, int weight);
         /// <summary>
         /// Reconnect the socket
         /// </summary>

CryptoExchange.Net/Logging/Extensions/CryptoExchangeWebSocketClientLoggingExtension.cs

@@ -3,7 +3,8 @@ using System;
 
 namespace CryptoExchange.Net.Logging.Extensions
 {
-    internal static class CryptoExchangeWebSocketClientLoggingExtension
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+    public static class CryptoExchangeWebSocketClientLoggingExtension
     {
         private static readonly Action<ILogger, int, Exception?> _connecting;
         private static readonly Action<ILogger, int, string, Exception?> _connectionFailed;
@@ -24,6 +25,7 @@ namespace CryptoExchange.Net.Logging.Extensions
         private static readonly Action<ILogger, int, string, Exception?> _sendLoopStoppedWithException;
         private static readonly Action<ILogger, int, Exception?> _sendLoopFinished;
         private static readonly Action<ILogger, int, string, string ,Exception?> _receivedCloseMessage;
+        private static readonly Action<ILogger, int, string, string ,Exception?> _receivedCloseConfirmation;
         private static readonly Action<ILogger, int, int, Exception?> _receivedPartialMessage;
         private static readonly Action<ILogger, int, int, Exception?> _receivedSingleMessage;
         private static readonly Action<ILogger, int, long, Exception?> _reassembledMessage;
@@ -32,6 +34,7 @@ namespace CryptoExchange.Net.Logging.Extensions
         private static readonly Action<ILogger, int, Exception?> _receiveLoopFinished;
         private static readonly Action<ILogger, int, TimeSpan?, Exception?> _startingTaskForNoDataReceivedCheck;
         private static readonly Action<ILogger, int, TimeSpan?, Exception?> _noDataReceiveTimoutReconnect;
+        private static readonly Action<ILogger, int, string, string, Exception?> _socketProcessingStateChanged;
 
         static CryptoExchangeWebSocketClientLoggingExtension()
         {
@@ -151,7 +154,7 @@ namespace CryptoExchange.Net.Logging.Extensions
                 "[Sckt {SocketId}] discarding incomplete message of {NumBytes} bytes");
 
             _receiveLoopStoppedWithException = LoggerMessage.Define<int>(
-                LogLevel.Warning,
+                LogLevel.Error,
                 new EventId(1024, "ReceiveLoopStoppedWithException"),
                 "[Sckt {SocketId}] receive loop stopped with exception");
 
@@ -169,6 +172,17 @@ namespace CryptoExchange.Net.Logging.Extensions
                 LogLevel.Debug,
                 new EventId(1027, "NoDataReceiveTimeoutReconnect"),
                 "[Sckt {SocketId}] no data received for {Timeout}, reconnecting socket");
+
+            _receivedCloseConfirmation = LoggerMessage.Define<int, string, string>(
+                LogLevel.Debug,
+                new EventId(1028, "ReceivedCloseMessage"),
+                "[Sckt {SocketId}] received `Close` message confirming our close request, CloseStatus: {CloseStatus}, CloseStatusDescription: {CloseStatusDescription}");
+
+            _socketProcessingStateChanged = LoggerMessage.Define<int, string, string>(
+                LogLevel.Trace,
+                new EventId(1028, "SocketProcessingStateChanged"),
+                "[Sckt {Id}] processing state change: {PreviousState} -> {NewState}");
+
         }
 
         public static void SocketConnecting(
@@ -285,6 +299,12 @@ namespace CryptoExchange.Net.Logging.Extensions
             _receivedCloseMessage(logger, socketId, webSocketCloseStatus, closeStatusDescription, null);
         }
 
+        public static void SocketReceivedCloseConfirmation(
+            this ILogger logger, int socketId, string webSocketCloseStatus, string closeStatusDescription)
+        {
+            _receivedCloseConfirmation(logger, socketId, webSocketCloseStatus, closeStatusDescription, null);
+        }
+
         public static void SocketReceivedPartialMessage(
             this ILogger logger, int socketId, int countBytes)
         {
@@ -332,5 +352,11 @@ namespace CryptoExchange.Net.Logging.Extensions
         {
             _noDataReceiveTimoutReconnect(logger, socketId, timeSpan, null);
         }
+
+        public static void SocketProcessingStateChanged(
+            this ILogger logger, int socketId, string prevState, string newState)
+        {
+            _socketProcessingStateChanged(logger, socketId, prevState, newState, null);
+        }
     }
 }

CryptoExchange.Net/Logging/Extensions/RateLimitGateLoggingExtensions.cs

@@ -3,7 +3,8 @@ using System;
 
 namespace CryptoExchange.Net.Logging.Extensions
 {
-    internal static class RateLimitGateLoggingExtensions
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+    public static class RateLimitGateLoggingExtensions
     {
         private static readonly Action<ILogger, int, string, string, string, Exception?> _rateLimitRequestFailed;
         private static readonly Action<ILogger, int, string, string, Exception?> _rateLimitConnectionFailed;

CryptoExchange.Net/Logging/Extensions/RestApiClientLoggingExtensions.cs

@@ -6,7 +6,8 @@ using System.Net.Http;
 
 namespace CryptoExchange.Net.Logging.Extensions
 {
-    internal static class RestApiClientLoggingExtensions
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+    public static class RestApiClientLoggingExtensions
     {
         private static readonly Action<ILogger, int?, int?, long, string?, Exception?> _restApiErrorReceived;
         private static readonly Action<ILogger, int?, int?, long, string?, Exception?> _restApiResponseReceived;

CryptoExchange.Net/Logging/Extensions/SocketApiClientLoggingExtension.cs

@@ -3,7 +3,8 @@ using System;
 
 namespace CryptoExchange.Net.Logging.Extensions
 {
-    internal static class SocketApiClientLoggingExtension
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+    public static class SocketApiClientLoggingExtension
     {
         private static readonly Action<ILogger, int, Exception?> _failedToAddSubscriptionRetryOnDifferentConnection;
         private static readonly Action<ILogger, int, Exception?> _hasBeenPausedCantSubscribeAtThisMoment;
@@ -21,6 +22,7 @@ namespace CryptoExchange.Net.Logging.Extensions
         private static readonly Action<ILogger, Exception?> _disposingSocketClient;
         private static readonly Action<ILogger, int, int, Exception?> _unsubscribingSubscription;
         private static readonly Action<ILogger, int, Exception?> _reconnectingAllConnections;
+        private static readonly Action<ILogger, DateTime, Exception?> _addingRetryAfterGuard;
 
         static SocketApiClientLoggingExtension()
         {
@@ -103,6 +105,11 @@ namespace CryptoExchange.Net.Logging.Extensions
                 LogLevel.Information,
                 new EventId(3017, "ReconnectingAll"),
                 "Reconnecting all {ConnectionCount} connections");
+
+            _addingRetryAfterGuard = LoggerMessage.Define<DateTime>(
+                LogLevel.Warning,
+                new EventId(3018, "AddRetryAfterGuard"),
+                "Adding RetryAfterGuard ({RetryAfter}) because the connection attempt was rate limited");
         }
 
         public static void FailedToAddSubscriptionRetryOnDifferentConnection(this ILogger logger, int socketId)
@@ -184,5 +191,10 @@ namespace CryptoExchange.Net.Logging.Extensions
         {
             _reconnectingAllConnections(logger, connectionCount, null);
         }
+
+        public static void AddingRetryAfterGuard(this ILogger logger, DateTime retryAfter)
+        {
+            _addingRetryAfterGuard(logger, retryAfter, null);
+        }
     }
 }

CryptoExchange.Net/Logging/Extensions/SocketConnectionLoggingExtension.cs

@@ -4,7 +4,8 @@ using Microsoft.Extensions.Logging;
 
 namespace CryptoExchange.Net.Logging.Extensions
 {
-    internal static class SocketConnectionLoggingExtension
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+    public static class SocketConnectionLoggingExtension
     {
         private static readonly Action<ILogger, int, bool, Exception?> _activityPaused;
         private static readonly Action<ILogger, int, Sockets.SocketConnection.SocketStatus, Sockets.SocketConnection.SocketStatus, Exception?> _socketStatusChanged;

CryptoExchange.Net/Logging/Extensions/SymbolOrderBookLoggingExtensions.cs

@@ -4,7 +4,9 @@ using Microsoft.Extensions.Logging;
 
 namespace CryptoExchange.Net.Logging.Extensions
 {
-    internal static class SymbolOrderBookLoggingExtensions
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+    public static class SymbolOrderBookLoggingExtensions
     {
         private static readonly Action<ILogger, string, string, OrderBookStatus, OrderBookStatus, Exception?> _orderBookStatusChanged;
         private static readonly Action<ILogger, string, string, Exception?> _orderBookStarting;

CryptoExchange.Net/Objects/ApiProxy.cs

@@ -1,6 +1,4 @@
-using System.Security;
-
-namespace CryptoExchange.Net.Objects
+namespace CryptoExchange.Net.Objects
 {
     /// <summary>
     /// Proxy info
@@ -24,14 +22,14 @@ namespace CryptoExchange.Net.Objects
         /// <summary>
         /// The password of the proxy
         /// </summary>
-        public SecureString? Password { get; }
+        public string? Password { get; }
 
         /// <summary>
         /// Create new settings for a proxy
         /// </summary>
         /// <param name="host">The proxy hostname/ip</param>
         /// <param name="port">The proxy port</param>
-        public ApiProxy(string host, int port): this(host, port, null, (SecureString?)null)
+        public ApiProxy(string host, int port): this(host, port, null, null)
         {
         }
 
@@ -42,18 +40,7 @@ namespace CryptoExchange.Net.Objects
         /// <param name="port">The proxy port</param>
         /// <param name="login">The proxy login</param>
         /// <param name="password">The proxy password</param>
-        public ApiProxy(string host, int port, string? login, string? password) : this(host, port, login, password?.ToSecureString())
-        {
-        }
-
-        /// <summary>
-        /// Create new settings for a proxy
-        /// </summary>
-        /// <param name="host">The proxy hostname/ip</param>
-        /// <param name="port">The proxy port</param>
-        /// <param name="login">The proxy login</param>
-        /// <param name="password">The proxy password</param>
-        public ApiProxy(string host, int port, string? login, SecureString? password)
+        public ApiProxy(string host, int port, string? login, string? password)
         {
             Host = host;
             Port = port;

CryptoExchange.Net/Objects/CallResult.cs

@@ -1,4 +1,5 @@
-using System;
+using CryptoExchange.Net.SharedApis;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Net;
@@ -273,6 +274,54 @@ namespace CryptoExchange.Net.Objects
             return new WebCallResult(ResponseStatusCode, ResponseHeaders, ResponseTime, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, error);
         }
 
+        /// <summary>
+        /// Copy the WebCallResult to a new data type
+        /// </summary>
+        /// <typeparam name="K">The new type</typeparam>
+        /// <param name="data">The data of the new type</param>
+        /// <returns></returns>
+        public WebCallResult<K> As<K>([AllowNull] K data)
+        {
+            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, 0, null, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Server, data, Error);
+        }
+
+        /// <summary>
+        /// Copy the WebCallResult to an ExchangeWebResult of a new data type
+        /// </summary>
+        /// <typeparam name="K">The new type</typeparam>
+        /// <param name="exchange">The exchange</param>
+        /// <param name="tradeMode">Trade mode the result applies to</param>
+        /// <param name="data">The data</param>
+        /// <returns></returns>
+        public ExchangeWebResult<K> AsExchangeResult<K>(string exchange, TradingMode tradeMode, [AllowNull] K data)
+        {
+            return new ExchangeWebResult<K>(exchange, tradeMode, this.As<K>(data));
+        }
+
+        /// <summary>
+        /// Copy the WebCallResult to an ExchangeWebResult of a new data type
+        /// </summary>
+        /// <typeparam name="K">The new type</typeparam>
+        /// <param name="exchange">The exchange</param>
+        /// <param name="tradeModes">Trade modes the result applies to</param>
+        /// <param name="data">The data</param>
+        /// <returns></returns>
+        public ExchangeWebResult<K> AsExchangeResult<K>(string exchange, TradingMode[]? tradeModes, [AllowNull] K data)
+        {
+            return new ExchangeWebResult<K>(exchange, tradeModes, this.As<K>(data));
+        }
+
+        /// <summary>
+        /// Copy the WebCallResult to a new data type
+        /// </summary>
+        /// <typeparam name="K">The new type</typeparam>
+        /// <param name="error">The error returned</param>
+        /// <returns></returns>
+        public WebCallResult<K> AsError<K>(Error error)
+        {
+            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, 0, null, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Server, default, error);
+        }
+
         /// <inheritdoc />
         public override string ToString()
         {
@@ -349,6 +398,7 @@ namespace CryptoExchange.Net.Objects
         /// <param name="requestBody"></param>
         /// <param name="requestMethod"></param>
         /// <param name="requestHeaders"></param>
+        /// <param name="dataSource"></param>
         /// <param name="data"></param>
         /// <param name="error"></param>
         public WebCallResult(
@@ -362,6 +412,7 @@ namespace CryptoExchange.Net.Objects
             string? requestBody,
             HttpMethod? requestMethod,
             IEnumerable<KeyValuePair<string, IEnumerable<string>>>? requestHeaders,
+            ResultDataSource dataSource,
             [AllowNull] T data,
             Error? error) : base(data, originalData, error)
         {
@@ -375,6 +426,7 @@ namespace CryptoExchange.Net.Objects
             RequestBody = requestBody;
             RequestHeaders = requestHeaders;
             RequestMethod = requestMethod;
+            DataSource = dataSource;
         }
 
         /// <summary>
@@ -398,7 +450,7 @@ namespace CryptoExchange.Net.Objects
         /// Create a new error result
         /// </summary>
         /// <param name="error">The error</param>
-        public WebCallResult(Error? error) : this(null, null, null, null, null, null, null, null, null, null, default, error) { }
+        public WebCallResult(Error? error) : this(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, default, error) { }
 
         /// <summary>
         /// Copy the WebCallResult to a new data type
@@ -408,7 +460,7 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         public new WebCallResult<K> As<K>([AllowNull] K data)
         {
-            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, data, Error);
+            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, data, Error);
         }
 
         /// <summary>
@@ -419,7 +471,69 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         public new WebCallResult<K> AsError<K>(Error error)
         {
-            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, default, error);
+            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, default, error);
+        }
+
+        /// <summary>
+        /// Copy the WebCallResult to an ExchangeWebResult of a new data type
+        /// </summary>
+        /// <param name="exchange">The exchange</param>
+        /// <param name="tradeMode">Trade mode the result applies to</param>
+        /// <returns></returns>
+        public ExchangeWebResult<T> AsExchangeResult(string exchange, TradingMode tradeMode)
+        {
+            return new ExchangeWebResult<T>(exchange, tradeMode, this);
+        }
+
+        /// <summary>
+        /// Copy the WebCallResult to an ExchangeWebResult of a new data type
+        /// </summary>
+        /// <param name="exchange">The exchange</param>
+        /// <param name="tradeModes">Trade modes the result applies to</param>
+        /// <returns></returns>
+        public ExchangeWebResult<T> AsExchangeResult(string exchange, TradingMode[] tradeModes)
+        {
+            return new ExchangeWebResult<T>(exchange, tradeModes, this);
+        }
+
+        /// <summary>
+        /// Copy the WebCallResult to an ExchangeWebResult of a new data type
+        /// </summary>
+        /// <typeparam name="K">The new type</typeparam>
+        /// <param name="exchange">The exchange</param>
+        /// <param name="tradeMode">Trade mode the result applies to</param>
+        /// <param name="data">Data</param>
+        /// <param name="nextPageToken">Next page token</param>
+        /// <returns></returns>
+        public ExchangeWebResult<K> AsExchangeResult<K>(string exchange, TradingMode tradeMode, [AllowNull] K data, INextPageToken? nextPageToken = null)
+        {
+            return new ExchangeWebResult<K>(exchange, tradeMode, As<K>(data), nextPageToken);
+        }
+
+        /// <summary>
+        /// Copy the WebCallResult to an ExchangeWebResult of a new data type
+        /// </summary>
+        /// <typeparam name="K">The new type</typeparam>
+        /// <param name="exchange">The exchange</param>
+        /// <param name="tradeModes">Trade modes the result applies to</param>
+        /// <param name="data">Data</param>
+        /// <param name="nextPageToken">Next page token</param>
+        /// <returns></returns>
+        public ExchangeWebResult<K> AsExchangeResult<K>(string exchange, TradingMode[]? tradeModes, [AllowNull] K data, INextPageToken? nextPageToken = null)
+        {
+            return new ExchangeWebResult<K>(exchange, tradeModes, As<K>(data), nextPageToken);
+        }
+
+        /// <summary>
+        /// Copy the WebCallResult to an ExchangeWebResult with a specific error
+        /// </summary>
+        /// <typeparam name="K">The new type</typeparam>
+        /// <param name="exchange">The exchange</param>
+        /// <param name="error">The error returned</param>
+        /// <returns></returns>
+        public ExchangeWebResult<K> AsExchangeError<K>(string exchange, Error error)
+        {
+            return new ExchangeWebResult<K>(exchange, null, AsError<K>(error));
         }
 
         /// <summary>
@@ -428,9 +542,7 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         internal WebCallResult<T> Cached()
         {
-            var result = new WebCallResult<T>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, default, Error);
-            result.DataSource = ResultDataSource.Cache;
-            return result;
+            return new WebCallResult<T>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Cache, Data, Error);
         }
 
         /// <inheritdoc />

CryptoExchange.Net/Objects/Enums.cs

@@ -152,7 +152,11 @@
         /// <summary>
         /// Round to closest value
         /// </summary>
-        Closest
+        Closest,
+        /// <summary>
+        /// Round up (ceil)
+        /// </summary>
+        Up
     }
 
     /// <summary>
@@ -203,4 +207,5 @@
         /// </summary>
         Cache
     }
+
 }

CryptoExchange.Net/Objects/Options/SocketExchangeOptions.cs

@@ -1,5 +1,4 @@
 using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Objects.Sockets;
 using System;
 
 namespace CryptoExchange.Net.Objects.Options
@@ -47,6 +46,12 @@ namespace CryptoExchange.Net.Objects.Options
         /// </summary>
         public TimeSpan DelayAfterConnect { get; set; } = TimeSpan.Zero;
 
+        /// <summary>
+        /// This delay is used to set a RetryAfter guard on the connection after a rate limit is hit on the server. 
+        /// This is used to prevent the client from reconnecting too quickly after a rate limit is hit.
+        /// </summary>
+        public TimeSpan? ConnectDelayAfterRateLimited { get; set; }
+
         /// <summary>
         /// Create a copy of this options
         /// </summary>

CryptoExchange.Net/Objects/ParameterCollection.cs

@@ -149,6 +149,27 @@ namespace CryptoExchange.Net.Objects
                 Add(key, DateTimeConverter.ConvertToSeconds(value));
         }
 
+        /// <summary>
+        /// Add a datetime value as string seconds timestamp
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="value"></param>
+        public void AddSecondsString(string key, DateTime value)
+        {
+            Add(key, DateTimeConverter.ConvertToSeconds(value).ToString());
+        }
+
+        /// <summary>
+        /// Add a datetime value as string seconds timestamp. Not added if value is null
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="value"></param>
+        public void AddOptionalSecondsString(string key, DateTime? value)
+        {
+            if (value != null)
+                Add(key, DateTimeConverter.ConvertToSeconds(value).ToString());
+        }
+
         /// <summary>
         /// Add an enum value as the string value as mapped using the <see cref="MapAttribute" />
         /// </summary>
@@ -167,7 +188,7 @@ namespace CryptoExchange.Net.Objects
         public void AddEnumAsInt<T>(string key, T value)
         {
             var stringVal = EnumConverter.GetString(value);
-            Add(key, EnumConverter.GetString(int.Parse(stringVal))!);
+            Add(key, int.Parse(stringVal)!);
         }
 
         /// <summary>

CryptoExchange.Net/Objects/RequestDefinition.cs

@@ -1,5 +1,4 @@
 using CryptoExchange.Net.RateLimiting.Interfaces;
-using System;
 using System.Net.Http;
 
 namespace CryptoExchange.Net.Objects
@@ -48,18 +47,16 @@ namespace CryptoExchange.Net.Objects
         /// 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
+        /// Individual endpoint rate limit guard to use
         /// </summary>
-        public int? EndpointLimitCount { get; set; }
-        /// <summary>
-        /// Rate limit period for this specific endpoint
-        /// </summary>
-        public TimeSpan? EndpointLimitPeriod { get; set; }
+        public IRateLimitGuard? LimitGuard { get; set; }
 
 
         /// <summary>

CryptoExchange.Net/Objects/RequestDefinitionCache.cs

@@ -1,7 +1,5 @@
 using CryptoExchange.Net.RateLimiting.Interfaces;
-using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
 using System.Net.Http;
 
 namespace CryptoExchange.Net.Objects
@@ -41,8 +39,7 @@ namespace CryptoExchange.Net.Objects
         /// <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="limitGuard">The rate limit guard 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>
@@ -56,8 +53,7 @@ namespace CryptoExchange.Net.Objects
             IRateLimitGate? rateLimitGate,
             int weight,
             bool authenticated,
-            int? endpointLimitCount = null,
-            TimeSpan? endpointLimitPeriod = null,
+            IRateLimitGuard? limitGuard = null,
             RequestBodyFormat? requestBodyFormat = null,
             HttpMethodParameterPosition? parameterPosition = null,
             ArrayParametersSerialization? arraySerialization = null,
@@ -69,8 +65,7 @@ namespace CryptoExchange.Net.Objects
                 def = new RequestDefinition(path, method)
                 {
                     Authenticated = authenticated,
-                    EndpointLimitCount = endpointLimitCount,
-                    EndpointLimitPeriod = endpointLimitPeriod,
+                    LimitGuard = limitGuard,
                     RateLimitGate = rateLimitGate,
                     Weight = weight,
                     ArraySerialization = arraySerialization,

CryptoExchange.Net/Objects/Sockets/DataEvent.cs

@@ -1,4 +1,5 @@
-using System;
+using CryptoExchange.Net.SharedApis;
+using System;
 
 namespace CryptoExchange.Net.Objects.Sockets
 {
@@ -38,7 +39,10 @@ namespace CryptoExchange.Net.Objects.Sockets
         /// </summary>
         public T Data { get; set; }
 
-        internal DataEvent(T data, string? streamId, string? symbol, string? originalData, DateTime timestamp, SocketUpdateType? updateType)
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public DataEvent(T data, string? streamId, string? symbol, string? originalData, DateTime timestamp, SocketUpdateType? updateType)
         {
             Data = data;
             StreamId = streamId;
@@ -85,6 +89,19 @@ namespace CryptoExchange.Net.Objects.Sockets
             return new DataEvent<K>(data, streamId, symbol, OriginalData, Timestamp, updateType);
         }
 
+        /// <summary>
+        /// Copy the WebCallResult to a new data type
+        /// </summary>
+        /// <typeparam name="K">The new type</typeparam>
+        /// <param name="exchange">The exchange the result is for</param>
+        /// <param name="data">The data</param>
+        /// <returns></returns>
+        public ExchangeEvent<K> AsExchangeEvent<K>(string exchange, K data)
+        {
+            return new ExchangeEvent<K>(exchange, this.As<K>(data));
+        }
+
+
         /// <summary>
         /// Specify the symbol
         /// </summary>
@@ -144,5 +161,11 @@ namespace CryptoExchange.Net.Objects.Sockets
         {
             return new CallResult<K>(default, OriginalData, error);
         }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"{StreamId} - {(Symbol == null ? "" : (Symbol + " - "))}{(UpdateType == null ? "" : (UpdateType + " - "))}{Data}";
+        }
     }
 }

CryptoExchange.Net/Objects/Sockets/UpdateSubscription.cs

@@ -30,6 +30,15 @@ namespace CryptoExchange.Net.Objects.Sockets
             remove => _connection.ConnectionClosed -= value;
         }
 
+        /// <summary>
+        /// Event when a lost connection is restored, but the resubscribing of update subscriptions failed
+        /// </summary>
+        public event Action<Error> ResubscribingFailed
+        {
+            add => _connection.ResubscribingFailed += value;
+            remove => _connection.ResubscribingFailed -= value;
+        }
+
         /// <summary>
         /// Event when the connection is restored. Timespan parameter indicates the time the socket has been offline for before reconnecting. 
         /// Note that when the executing code is suspended and resumed at a later period (for example, a laptop going to sleep) the disconnect time will be incorrect as the diconnect

CryptoExchange.Net/OrderBook/SymbolOrderBook.cs

@@ -810,7 +810,7 @@ namespace CryptoExchange.Net.OrderBook
         {
             if (lastUpdateId <= LastSequenceNumber)
             {
-                _logger.OrderBookUpdateSkipped(Api, Symbol, firstUpdateId, lastUpdateId);
+                _logger.OrderBookUpdateSkipped(Api, Symbol, lastUpdateId, LastSequenceNumber);
                 return;
             }
 

CryptoExchange.Net/RateLimiting/Filters/AuthenticatedEndpointFilter.cs

@@ -1,6 +1,5 @@
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.RateLimiting.Interfaces;
-using System.Security;
 
 namespace CryptoExchange.Net.RateLimiting.Filters
 {
@@ -21,7 +20,7 @@ namespace CryptoExchange.Net.RateLimiting.Filters
         }
 
         /// <inheritdoc />
-        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey)
             => definition.Authenticated == _authenticated;
     }
 }

CryptoExchange.Net/RateLimiting/Filters/ExactPathFilter.cs

@@ -1,9 +1,6 @@
 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
 {
@@ -24,7 +21,7 @@ namespace CryptoExchange.Net.RateLimiting.Filters
         }
 
         /// <inheritdoc />
-        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey)
             => string.Equals(definition.Path, _path, StringComparison.OrdinalIgnoreCase);
     }
 }

CryptoExchange.Net/RateLimiting/Filters/ExactPathsFilter.cs

@@ -1,7 +1,6 @@
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.RateLimiting.Interfaces;
 using System.Collections.Generic;
-using System.Security;
 
 namespace CryptoExchange.Net.RateLimiting.Filters
 {
@@ -22,7 +21,7 @@ namespace CryptoExchange.Net.RateLimiting.Filters
         }
 
         /// <inheritdoc />
-        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey)
             => _paths.Contains(definition.Path);
     }
 }

CryptoExchange.Net/RateLimiting/Filters/HostFilter.cs

@@ -1,6 +1,5 @@
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.RateLimiting.Interfaces;
-using System.Security;
 
 namespace CryptoExchange.Net.RateLimiting.Filters
 {
@@ -21,7 +20,7 @@ namespace CryptoExchange.Net.RateLimiting.Filters
         }
 
         /// <inheritdoc />
-        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey)
             => host == _host;
 
     }

CryptoExchange.Net/RateLimiting/Filters/LimitItemTypeFilter.cs

@@ -1,6 +1,5 @@
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.RateLimiting.Interfaces;
-using System.Security;
 
 namespace CryptoExchange.Net.RateLimiting.Filters
 {
@@ -21,7 +20,7 @@ namespace CryptoExchange.Net.RateLimiting.Filters
         }
 
         /// <inheritdoc />
-        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey)
             => type == _type;
     }
 }

CryptoExchange.Net/RateLimiting/Filters/PathStartFilter.cs

@@ -1,7 +1,6 @@
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.RateLimiting.Interfaces;
 using System;
-using System.Security;
 
 namespace CryptoExchange.Net.RateLimiting.Filters
 {
@@ -22,7 +21,7 @@ namespace CryptoExchange.Net.RateLimiting.Filters
         }
 
         /// <inheritdoc />
-        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey)
             => definition.Path.StartsWith(_path, StringComparison.OrdinalIgnoreCase);
     }
 }

CryptoExchange.Net/RateLimiting/Guards/RateLimitGuard.cs

@@ -3,8 +3,6 @@ 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
 {
@@ -14,26 +12,26 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         /// <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);
+        public static Func<RequestDefinition, string, string?, string> PerHost { get; } = new Func<RequestDefinition, string, string?, 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);
+        public static Func<RequestDefinition, string, string?, string> PerEndpoint { get; } = new Func<RequestDefinition, string, string?, 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());
+        public static Func<RequestDefinition, string, string?, string> PerApiKey { get; } = new Func<RequestDefinition, string, string?, string>((def, host, key) => key!);
         /// <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);
+        public static Func<RequestDefinition, string, string?, string> PerApiKeyPerEndpoint { get; } = new Func<RequestDefinition, string, string?, string>((def, host, key) => key! + 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;
+        private readonly Func<RequestDefinition, string, string?, string> _keySelector;
 
         /// <inheritdoc />
         public string Name => "RateLimitGuard";
@@ -60,7 +58,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         /// <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)
+        public RateLimitGuard(Func<RequestDefinition, string, string?, 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)
         {
         }
@@ -75,7 +73,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         /// <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)
+        public RateLimitGuard(Func<RequestDefinition, string, string?, string> keySelector, IEnumerable<IGuardFilter> filters, int limit, TimeSpan timeSpan, RateLimitWindowType windowType, double? decayPerTimeSpan = null, int? connectionWeight = null)
         {
             _filters = filters;
             _trackers = new Dictionary<string, IWindowTracker>();
@@ -88,7 +86,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         }
 
         /// <inheritdoc />
-        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight)
         {
             foreach(var filter in _filters)
             {
@@ -114,7 +112,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         }
 
         /// <inheritdoc />
-        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight)
         {
             foreach (var filter in _filters)
             {

CryptoExchange.Net/RateLimiting/Guards/RetryAfterGuard.cs

@@ -1,9 +1,6 @@
 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
 {
@@ -21,25 +18,35 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         public string Name => "RetryAfterGuard";
 
         /// <inheritdoc />
-        public string Description => $"Pause requests until after {After}";
+        public string Description => $"Pause {Type} until after {After}";
 
         /// <summary>
         /// The timestamp after which requests are allowed again
         /// </summary>
         public DateTime After { get; private set; }
 
+        /// <summary>
+        /// The type of rate limit item this guard is for
+        /// </summary>
+        public RateLimitItemType Type { get; private set; }
+
         /// <summary>
         /// ctor
         /// </summary>
         /// <param name="after"></param>
-        public RetryAfterGuard(DateTime after)
+        /// <param name="type"></param>
+        public RetryAfterGuard(DateTime after, RateLimitItemType type)
         {
             After = after;
+            Type = type;
         }
 
         /// <inheritdoc />
-        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight)
         {
+            if (type != Type)
+                return LimitCheck.NotApplicable;
+
             var dif = (After + _windowBuffer) - DateTime.UtcNow;
             if (dif <= TimeSpan.Zero)
                 return LimitCheck.NotApplicable;
@@ -48,7 +55,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         }
 
         /// <inheritdoc />
-        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight)
         {
             return RateLimitState.NotApplied;
         }

CryptoExchange.Net/RateLimiting/Guards/SingleLimitGuard.cs

@@ -3,7 +3,6 @@ using CryptoExchange.Net.RateLimiting.Interfaces;
 using CryptoExchange.Net.RateLimiting.Trackers;
 using System;
 using System.Collections.Generic;
-using System.Security;
 
 namespace CryptoExchange.Net.RateLimiting.Guards
 {
@@ -12,9 +11,22 @@ namespace CryptoExchange.Net.RateLimiting.Guards
     /// </summary>
     public class SingleLimitGuard : IRateLimitGuard
     {
+        /// <summary>
+        /// Default endpoint limit
+        /// </summary>
+        public static Func<RequestDefinition, string, string?, string> Default { get; } = new Func<RequestDefinition, string, string?, string>((def, host, key) => def.Path + def.Method);
+
+        /// <summary>
+        /// Endpoint limit per API key
+        /// </summary>
+        public static Func<RequestDefinition, string, string?, string> PerApiKey { get; } = new Func<RequestDefinition, string, string?, string>((def, host, key) => def.Path + def.Method);
+
         private readonly Dictionary<string, IWindowTracker> _trackers;
         private readonly RateLimitWindowType _windowType;
         private readonly double? _decayRate;
+        private readonly int _limit;
+        private readonly TimeSpan _period;
+        private readonly Func<RequestDefinition, string, string?, string> _keySelector;
 
         /// <inheritdoc />
         public string Name => "EndpointLimitGuard";
@@ -25,20 +37,28 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         /// <summary>
         /// ctor
         /// </summary>
-        public SingleLimitGuard(RateLimitWindowType windowType, double? decayRate = null)
+        public SingleLimitGuard(
+            int limit,
+            TimeSpan period,
+            RateLimitWindowType windowType,
+            double? decayRate = null,
+            Func<RequestDefinition, string, string?, string>? keySelector = null)
         {
+            _limit = limit;
+            _period = period;
             _windowType = windowType;
             _decayRate = decayRate;
+            _keySelector = keySelector ?? Default;
             _trackers = new Dictionary<string, IWindowTracker>();
         }
 
         /// <inheritdoc />
-        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight)
         {
-            var key = definition.Path + definition.Method;
+            var key = _keySelector(definition, host, apiKey);
             if (!_trackers.TryGetValue(key, out var tracker))
             {
-                tracker = CreateTracker(definition.EndpointLimitCount!.Value, definition.EndpointLimitPeriod!.Value);
+                tracker = CreateTracker();
                 _trackers.Add(key, tracker);
             }
 
@@ -46,27 +66,27 @@ namespace CryptoExchange.Net.RateLimiting.Guards
             if (delay == default)
                 return LimitCheck.NotNeeded;
 
-            return LimitCheck.Needed(delay, definition.EndpointLimitCount!.Value, definition.EndpointLimitPeriod!.Value, tracker.Current);
+            return LimitCheck.Needed(delay, _limit, _period, tracker.Current);
         }
 
         /// <inheritdoc />
-        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight)
         {
-            var key = definition.Path + definition.Method;
+            var key = _keySelector(definition, host, apiKey);
             var tracker = _trackers[key];
             tracker.ApplyWeight(requestWeight);
-            return RateLimitState.Applied(definition.EndpointLimitCount!.Value, definition.EndpointLimitPeriod!.Value, tracker.Current);
+            return RateLimitState.Applied(_limit, _period, tracker.Current);
         }
 
         /// <summary>
         /// Create a new WindowTracker
         /// </summary>
         /// <returns></returns>
-        protected IWindowTracker CreateTracker(int limit, TimeSpan timeSpan)
+        protected IWindowTracker CreateTracker()
         {
-            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"));
+            return _windowType == RateLimitWindowType.Sliding ? new SlidingWindowTracker(_limit, _period)
+                : _windowType == RateLimitWindowType.Fixed ? new FixedWindowTracker(_limit, _period) :
+                new DecayWindowTracker(_limit, _period, _decayRate ?? throw new InvalidOperationException("Decay rate not provided"));
         }
     }
 }

CryptoExchange.Net/RateLimiting/Interfaces/IGuardFilter.cs

@@ -1,5 +1,4 @@
 using CryptoExchange.Net.Objects;
-using System.Security;
 
 namespace CryptoExchange.Net.RateLimiting.Interfaces
 {
@@ -16,6 +15,6 @@ namespace CryptoExchange.Net.RateLimiting.Interfaces
         /// <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);
+        bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey);
     }
 }

CryptoExchange.Net/RateLimiting/Interfaces/IRateLimitGate.cs

@@ -1,8 +1,6 @@
 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;
 
@@ -29,15 +27,9 @@ namespace CryptoExchange.Net.RateLimiting.Interfaces
         /// 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>
+        /// <param name="type">RateLimitType</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);
+        Task SetRetryAfterGuardAsync(DateTime retryAfter, RateLimitItemType type = RateLimitItemType.Request);
 
         /// <summary>
         /// Returns the 'retry after' timestamp if set
@@ -58,21 +50,21 @@ namespace CryptoExchange.Net.RateLimiting.Interfaces
         /// <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);
+        Task<CallResult> ProcessAsync(ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string baseAddress, string? 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="guard">The guard</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);
+        Task<CallResult> ProcessSingleAsync(ILogger logger, int itemId, IRateLimitGuard guard, RateLimitItemType type, RequestDefinition definition, string baseAddress, string? apiKey, RateLimitingBehaviour behaviour, CancellationToken ct);
     }
 }

CryptoExchange.Net/RateLimiting/Interfaces/IRateLimitGuard.cs

@@ -1,6 +1,4 @@
 using CryptoExchange.Net.Objects;
-using System.Net.Http;
-using System.Security;
 
 namespace CryptoExchange.Net.RateLimiting.Interfaces
 {
@@ -28,7 +26,7 @@ namespace CryptoExchange.Net.RateLimiting.Interfaces
         /// <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);
+        LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight);
 
         /// <summary>
         /// Apply the request to this guard with the specified weight
@@ -39,6 +37,6 @@ namespace CryptoExchange.Net.RateLimiting.Interfaces
         /// <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);
+        RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight);
     }
 }

CryptoExchange.Net/RateLimiting/RateLimitGate.cs

@@ -7,7 +7,6 @@ using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
-using System.Security;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -16,7 +15,6 @@ 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;
@@ -33,45 +31,67 @@ namespace CryptoExchange.Net.RateLimiting
         {
             _name = name;
             _guards = new ConcurrentBag<IRateLimitGuard>();
-            _semaphore = new SemaphoreSlim(1);
+            _semaphore = new SemaphoreSlim(1, 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)
+        public async Task<CallResult> ProcessAsync(ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight, RateLimitingBehaviour rateLimitingBehaviour, CancellationToken ct)
         {
             await _semaphore.WaitAsync(ct).ConfigureAwait(false);
+            bool release = true;
             _waitingCount++;
             try
             {
                 return await CheckGuardsAsync(_guards, logger, itemId, type, definition, host, apiKey, requestWeight, rateLimitingBehaviour, ct).ConfigureAwait(false);
             }
+            catch (TaskCanceledException)
+            {
+                // The semaphore has already been released if the task was cancelled
+                release = false;
+                return new CallResult(new CancellationRequestedError());
+            }
             finally
             {
                 _waitingCount--;
-                _semaphore.Release();
+                if (release)
+                    _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)
+        public async Task<CallResult> ProcessSingleAsync(
+            ILogger logger,
+            int itemId,
+            IRateLimitGuard guard,
+            RateLimitItemType type,
+            RequestDefinition definition, 
+            string host,
+            string? apiKey,
+            RateLimitingBehaviour rateLimitingBehaviour,
+            CancellationToken ct)
         {
             await _semaphore.WaitAsync(ct).ConfigureAwait(false);
-            if (requestWeight == 0)
-                requestWeight = 1;
-
+            bool release = true;
             _waitingCount++;
             try
             {
-                return await CheckGuardsAsync(new IRateLimitGuard[] { _singleLimitGuard }, logger, itemId, type, definition, host, apiKey, requestWeight, rateLimitingBehaviour, ct).ConfigureAwait(false);
+                return await CheckGuardsAsync(new IRateLimitGuard[] { guard }, logger, itemId, type, definition, host, apiKey, 1, rateLimitingBehaviour, ct).ConfigureAwait(false);
+            }
+            catch (TaskCanceledException)
+            {
+                // The semaphore has already been released if the task was cancelled
+                release = false;
+                return new CallResult(new CancellationRequestedError());
             }
             finally
             {
                 _waitingCount--;
-                _semaphore.Release();
+                if (release)
+                    _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)
+        private async Task<CallResult> CheckGuardsAsync(IEnumerable<IRateLimitGuard> guards, ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight, RateLimitingBehaviour rateLimitingBehaviour, CancellationToken ct)
         {
             foreach (var guard in guards)
             {
@@ -131,14 +151,7 @@ namespace CryptoExchange.Net.RateLimiting
         }
 
         /// <inheritdoc />
-        public IRateLimitGate SetSingleLimitGuard(SingleLimitGuard guard)
-        {
-            _singleLimitGuard = guard;
-            return this;
-        }
-
-        /// <inheritdoc />
-        public async Task SetRetryAfterGuardAsync(DateTime retryAfter)
+        public async Task SetRetryAfterGuardAsync(DateTime retryAfter, RateLimitItemType type)
         {
             await _semaphore.WaitAsync().ConfigureAwait(false);
 
@@ -146,7 +159,7 @@ namespace CryptoExchange.Net.RateLimiting
             {
                 var retryAfterGuard = _guards.OfType<RetryAfterGuard>().SingleOrDefault();
                 if (retryAfterGuard == null)
-                    _guards.Add(new RetryAfterGuard(retryAfter));
+                    _guards.Add(new RetryAfterGuard(retryAfter, type));
                 else
                     retryAfterGuard.UpdateAfter(retryAfter);
             }

CryptoExchange.Net/RateLimiting/Trackers/DecayWindowTracker.cs

@@ -80,7 +80,10 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
         private TimeSpan DetermineWaitTime(int requestWeight)
         {
             var weightToRemove = Math.Max(Current - (Limit - requestWeight), 0);
-            return TimeSpan.FromMilliseconds(Math.Ceiling(weightToRemove / DecreaseRate) * TimePeriod.TotalMilliseconds);
+            var result = TimeSpan.FromMilliseconds(Math.Ceiling(weightToRemove / DecreaseRate) * TimePeriod.TotalMilliseconds);
+            if (result < TimeSpan.Zero)
+                return TimeSpan.Zero;
+            return result;
         }
     }
 }

CryptoExchange.Net/RateLimiting/Trackers/FixedAfterStartWindowTracker.cs

@@ -97,7 +97,10 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
         private TimeSpan DetermineWaitTime()
         {
             var checkTime = DateTime.UtcNow;
-            return (_nextReset!.Value - checkTime) + _fixedWindowBuffer;
+            var result = (_nextReset!.Value - checkTime) + _fixedWindowBuffer;
+            if (result < TimeSpan.Zero)
+                return TimeSpan.Zero;
+            return result;
         }
     }
 }

CryptoExchange.Net/RateLimiting/Trackers/FixedWindowTracker.cs

@@ -93,7 +93,10 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
             var checkTime = DateTime.UtcNow;
             var startCurrentWindow = checkTime.AddTicks(-(checkTime.Ticks % TimePeriod.Ticks));
             var wait = startCurrentWindow.Add(TimePeriod) - checkTime;
-            return wait.Add(_fixedWindowBuffer);
+            var result = wait.Add(_fixedWindowBuffer);
+            if (result < TimeSpan.Zero)
+                return TimeSpan.Zero;
+            return result;
         }
     }
 }

CryptoExchange.Net/RateLimiting/Trackers/SlidingWindowTracker.cs

@@ -16,6 +16,11 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
         private readonly List<LimitEntry> _entries;
         private int _currentWeight = 0;
 
+        /// <summary>
+        /// Additional wait time to apply to account for fluctuating request times
+        /// </summary>
+        private static readonly TimeSpan _slidingWindowBuffer = TimeSpan.FromMilliseconds(1000);
+
         public SlidingWindowTracker(int limit, TimeSpan period)
         {
             Limit = limit;
@@ -89,7 +94,10 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
                 removedWeight += entry.Weight;
                 if (removedWeight >= weightToRemove)
                 {
-                    return entry.Timestamp + TimePeriod - DateTime.UtcNow;
+                    var result = entry.Timestamp + TimePeriod + _slidingWindowBuffer - DateTime.UtcNow;
+                    if (result < TimeSpan.Zero)
+                        return TimeSpan.Zero;
+                    return result;
                 }
             }
 

CryptoExchange.Net/SharedApis/Enums/SharedFeeAssetType.cs

@@ -0,0 +1,29 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Fee asset selection type
+    /// </summary>
+    public enum SharedFeeAssetType
+    {
+        /// <summary>
+        /// Fee is always in the base asset
+        /// </summary>
+        BaseAsset,
+        /// <summary>
+        /// Fee is always in the quote asset
+        /// </summary>
+        QuoteAsset,
+        /// <summary>
+        /// Fee is always in the input asset
+        /// </summary>
+        InputAsset,
+        /// <summary>
+        /// Fee is always in the output asset
+        /// </summary>
+        OutputAsset,
+        /// <summary>
+        /// Fee is variable
+        /// </summary>
+        Variable
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedFeeDeductionType.cs

@@ -0,0 +1,17 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Fee deduction type
+    /// </summary>
+    public enum SharedFeeDeductionType
+    {
+        /// <summary>
+        /// The fee is deducted from the output amount. For example buying 1 ETH at 1000 USDT with a 1% fee would cost 1000 USDT and output 0.99 ETH
+        /// </summary>
+        DeductFromOutput,
+        /// <summary>
+        /// The fee is added to the order cost. For example buying 1 ETH at 1000 USDT with a 1% fee would cost 1010 USDT and output 1 ETH
+        /// </summary>
+        AddToCost
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedKlineInterval.cs

@@ -0,0 +1,33 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Kline interval
+    /// </summary>
+    public enum SharedKlineInterval
+    {
+        /// <summary>
+        /// 5 min
+        /// </summary>
+        FiveMinutes = 60 * 5,
+        /// <summary>
+        /// 15 min
+        /// </summary>
+        FifteenMinutes = 60 * 15,
+        /// <summary>
+        /// 1 hour
+        /// </summary>
+        OneHour = 60 * 60,
+        /// <summary>
+        /// 1 day
+        /// </summary>
+        OneDay = 60 * 60 * 24,
+        /// <summary>
+        /// 1 week
+        /// </summary>
+        OneWeek = 60 * 60 * 24 * 7,
+        /// <summary>
+        /// 1 month
+        /// </summary>
+        OneMonth = 60 * 60 * 24 * 30
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedLeverageSettingMode.cs

@@ -0,0 +1,17 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Leverage setting mode
+    /// </summary>
+    public enum SharedLeverageSettingMode
+    {
+        /// <summary>
+        /// Leverage is configured per side (in hedge mode)
+        /// </summary>
+        PerSide,
+        /// <summary>
+        /// Leverage is configured for the symbol
+        /// </summary>
+        PerSymbol
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedMarginMode.cs

@@ -0,0 +1,17 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Margin mode
+    /// </summary>
+    public enum SharedMarginMode
+    {
+        /// <summary>
+        /// Cross margin, margin is shared across symbols
+        /// </summary>
+        Cross,
+        /// <summary>
+        /// Isolated margin, margin is isolated on a symbol
+        /// </summary>
+        Isolated
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedOrderSide.cs

@@ -0,0 +1,17 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Side of an order
+    /// </summary>
+    public enum SharedOrderSide
+    {
+        /// <summary>
+        /// Buy order
+        /// </summary>
+        Buy,
+        /// <summary>
+        /// Sell order
+        /// </summary>
+        Sell
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedOrderStatus.cs

@@ -0,0 +1,21 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Status of an order
+    /// </summary>
+    public enum SharedOrderStatus
+    {
+        /// <summary>
+        /// Order is open waiting to be filled
+        /// </summary>
+        Open,
+        /// <summary>
+        /// Order has been fully filled
+        /// </summary>
+        Filled,
+        /// <summary>
+        /// Order has been canceled
+        /// </summary>
+        Canceled
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedOrderType.cs

@@ -0,0 +1,25 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Type of an order
+    /// </summary>
+    public enum SharedOrderType
+    {
+        /// <summary>
+        /// Limit order, execute at a specific price
+        /// </summary>
+        Limit,
+        /// <summary>
+        /// Limit maker order, a limit order with the condition that is will never be executed as a maker
+        /// </summary>
+        LimitMaker,
+        /// <summary>
+        /// Market order, execute at the best price currently available
+        /// </summary>
+        Market,
+        /// <summary>
+        /// Other order type, used for parsing unsupported order types
+        /// </summary>
+        Other
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedPaginationSupport.cs

@@ -0,0 +1,21 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Supported pagination type
+    /// </summary>
+    public enum SharedPaginationSupport
+    {
+        /// <summary>
+        /// Pagination is not supported for this exchange request
+        /// </summary>
+        NotSupported,
+        /// <summary>
+        /// Pagination is in ascending order
+        /// </summary>
+        Ascending,
+        /// <summary>
+        /// Pagination is in descending order
+        /// </summary>
+        Descending
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedPositionMode.cs

@@ -0,0 +1,17 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Position mode
+    /// </summary>
+    public enum SharedPositionMode
+    {
+        /// <summary>
+        /// Hedge mode, a symbol can have both a long and a short position at the same time
+        /// </summary>
+        HedgeMode,
+        /// <summary>
+        /// One way mode, a symbol can only have one open position side at a time
+        /// </summary>
+        OneWay
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedPositionModeSelection.cs

@@ -0,0 +1,17 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Position mode selection type
+    /// </summary>
+    public enum SharedPositionModeSelection
+    {
+        /// <summary>
+        /// Position mode is configured per symbol
+        /// </summary>
+        PerSymbol,
+        /// <summary>
+        /// Position mode is configured for the entire account
+        /// </summary>
+        PerAccount
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedPositionSide.cs

@@ -0,0 +1,17 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// The side of a position
+    /// </summary>
+    public enum SharedPositionSide
+    {
+        /// <summary>
+        /// Long position
+        /// </summary>
+        Long,
+        /// <summary>
+        /// Short position
+        /// </summary>
+        Short
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedQuoteQuantitySupport.cs

@@ -0,0 +1,25 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Quote asset order quantity support
+    /// </summary>
+    public enum SharedQuantityType
+    {
+        /// <summary>
+        /// Quantity should be in the base asset
+        /// </summary>
+        BaseAsset,
+        /// <summary>
+        /// Quantity should be in the quote asset
+        /// </summary>
+        QuoteAsset,
+        /// <summary>
+        /// Quantity is in the number of contracts
+        /// </summary>
+        Contracts,
+        /// <summary>
+        /// Quantity can be either base or quote quantity
+        /// </summary>
+        BaseAndQuoteAsset
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedRole.cs

@@ -0,0 +1,17 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// The role of a trade
+    /// </summary>
+    public enum SharedRole
+    {
+        /// <summary>
+        /// Maker role, put an order on the order book which has been filled
+        /// </summary>
+        Maker,
+        /// <summary>
+        /// Taker role, took an order of the order book to fill
+        /// </summary>
+        Taker
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedSymbolType.cs

@@ -0,0 +1,25 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Type of a symbol
+    /// </summary>
+    public enum SharedSymbolType
+    {
+        /// <summary>
+        /// Perpetual linear, contract has no delivery date and is settled in stablecoin
+        /// </summary>
+        PerpetualLinear,
+        /// <summary>
+        /// Perpetual inverse, contract has no delivery date and is settled in crypto
+        /// </summary>
+        PerpetualInverse,
+        /// <summary>
+        /// Delivery linear, contract has a specific delivery date and is settled in stablecoin
+        /// </summary>
+        DeliveryLinear,
+        /// <summary>
+        /// Delivery inverse, contract has a specific delivery date and is settled in crypto
+        /// </summary>
+        DeliveryInverse
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedTimeInForce.cs

@@ -0,0 +1,21 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Time in force for an order
+    /// </summary>
+    public enum SharedTimeInForce
+    {
+        /// <summary>
+        /// Order is good until canceled
+        /// </summary>
+        GoodTillCanceled,
+        /// <summary>
+        /// Order should execute immediately, not executed part is canceled
+        /// </summary>
+        ImmediateOrCancel,
+        /// <summary>
+        /// Order should execute fully immediately or is fully canceled
+        /// </summary>
+        FillOrKill
+    }
+}

CryptoExchange.Net/SharedApis/Enums/TradingMode.cs

@@ -0,0 +1,29 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Trading mode
+    /// </summary>
+    public enum TradingMode
+    {
+        /// <summary>
+        /// Spot trading
+        /// </summary>
+        Spot,
+        /// <summary>
+        /// Perpetual linear futures
+        /// </summary>
+        PerpetualLinear,
+        /// <summary>
+        /// Delivery linear futures
+        /// </summary>
+        DeliveryLinear,
+        /// <summary>
+        /// Perpetual inverse futures
+        /// </summary>
+        PerpetualInverse,
+        /// <summary>
+        /// Delivery inverse futures
+        /// </summary>
+        DeliveryInverse
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/INextPageToken.cs

@@ -0,0 +1,111 @@
+using System;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// A token which a request can use to retrieve the next page if there are more pages in the result set
+    /// </summary>
+    public interface INextPageToken
+    {
+    }
+
+    /// <summary>
+    /// A datetime offset token
+    /// </summary>
+    public record DateTimeToken: INextPageToken
+    {
+        /// <summary>
+        /// Last result time
+        /// </summary>
+        public DateTime LastTime { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public DateTimeToken(DateTime timestamp)
+        {
+            LastTime = timestamp;
+        }
+    }
+
+    /// <summary>
+    /// A current page index token
+    /// </summary>
+    public record PageToken: INextPageToken
+    {
+        /// <summary>
+        /// The next page index
+        /// </summary>
+        public int Page { get; set; }
+        /// <summary>
+        /// Page size
+        /// </summary>
+        public int PageSize { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public PageToken(int page, int pageSize)
+        {
+            Page = page;
+            PageSize = pageSize;
+        }
+    }
+
+    /// <summary>
+    /// A id offset token
+    /// </summary>
+    public record FromIdToken : INextPageToken
+    {
+        /// <summary>
+        /// The last id from previous result
+        /// </summary>
+        public string FromToken { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public FromIdToken(string fromToken)
+        {
+            FromToken = fromToken;
+        }
+    }
+
+    /// <summary>
+    /// A cursor token
+    /// </summary>
+    public record CursorToken : INextPageToken
+    {
+        /// <summary>
+        /// The next page cursor
+        /// </summary>
+        public string Cursor { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public CursorToken(string cursor)
+        {
+            Cursor = cursor;
+        }
+    }
+
+    /// <summary>
+    /// A result offset token
+    /// </summary>
+    public record OffsetToken : INextPageToken
+    {
+        /// <summary>
+        /// Offset in the result set
+        /// </summary>
+        public int Offset { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public OffsetToken(int offset)
+        {
+            Offset = offset;
+        }
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/ISharedClient.cs

@@ -0,0 +1,43 @@
+using CryptoExchange.Net.Objects;
+using System;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// A shared/common client interface
+    /// </summary>
+    public interface ISharedClient
+    {
+        /// <summary>
+        /// Name of the exchange
+        /// </summary>
+        string Exchange { get; }
+
+        /// <summary>
+        /// Which trading modes this client supports
+        /// </summary>
+        TradingMode[] SupportedTradingModes { get; }
+
+        /// <summary>
+        /// Format a base and quote asset to an exchange accepted symbol 
+        /// </summary>
+        /// <param name="baseAsset">The base asset</param>
+        /// <param name="quoteAsset">The quote asset</param>
+        /// <param name="tradingMode">The trading mode</param>
+        /// <param name="deliverDate">The deliver date for a delivery futures symbol</param>
+        /// <returns></returns>
+        string FormatSymbol(string baseAsset, string quoteAsset, TradingMode tradingMode, DateTime? deliverDate = null);
+
+        /// <summary>
+        /// Set a default exchange parameter. This can be used instead of passing in an ExchangeParameters object which each request.
+        /// </summary>
+        /// <param name="name">Parameter name</param>
+        /// <param name="value">Parameter value</param>
+        void SetDefaultExchangeParameter(string name, object value);
+
+        /// <summary>
+        /// Reset the default exchange parameters, resets parameters for all exchanges
+        /// </summary>
+        void ResetDefaultExchangeParameters();
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/Rest/Futures/IFundingRateRestClient.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for request funding rate records
+    /// </summary>
+    public interface IFundingRateRestClient : ISharedClient
+    {
+        /// <summary>
+        /// Funding rate request options
+        /// </summary>
+        GetFundingRateHistoryOptions GetFundingRateHistoryOptions { get; }
+        /// <summary>
+        /// Get funding rate records
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="nextPageToken">The pagination token from the previous request to continue pagination</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<ExchangeWebResult<IEnumerable<SharedFundingRate>>> GetFundingRateHistoryAsync(GetFundingRateHistoryRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/Rest/Futures/IFuturesOrderRestClient.cs

@@ -0,0 +1,136 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for placing and managing futures orders
+    /// </summary>
+    public interface IFuturesOrderRestClient : ISharedClient
+    {
+        /// <summary>
+        /// How the trading fee is deducted
+        /// </summary>
+        SharedFeeDeductionType FuturesFeeDeductionType { get; }
+        /// <summary>
+        /// How the asset is determined in which the trading fee is paid
+        /// </summary>
+        SharedFeeAssetType FuturesFeeAssetType { get; }
+
+        /// <summary>
+        /// Supported order types
+        /// </summary>
+        IEnumerable<SharedOrderType> FuturesSupportedOrderTypes { get; }
+        /// <summary>
+        /// Supported time in force
+        /// </summary>
+        IEnumerable<SharedTimeInForce> FuturesSupportedTimeInForce { get; }
+        /// <summary>
+        /// Quantity types support
+        /// </summary>
+        SharedQuantitySupport FuturesSupportedOrderQuantity { get; }
+
+        /// <summary>
+        /// Futures place order request options
+        /// </summary>
+        PlaceFuturesOrderOptions PlaceFuturesOrderOptions { get; }
+        /// <summary>
+        /// Place a new futures order
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<ExchangeWebResult<SharedId>> PlaceFuturesOrderAsync(PlaceFuturesOrderRequest request, CancellationToken ct = default);
+
+        /// <summary>
+        /// Futures get order request options
+        /// </summary>
+        EndpointOptions<GetOrderRequest> GetFuturesOrderOptions { get; }
+        /// <summary>
+        /// Get info on a specific futures order
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<ExchangeWebResult<SharedFuturesOrder>> GetFuturesOrderAsync(GetOrderRequest request, CancellationToken ct = default);
+
+        /// <summary>
+        /// Futures get open orders request options
+        /// </summary>
+        EndpointOptions<GetOpenOrdersRequest> GetOpenFuturesOrdersOptions { get; }
+        /// <summary>
+        /// Get info on a open futures orders
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<ExchangeWebResult<IEnumerable<SharedFuturesOrder>>> GetOpenFuturesOrdersAsync(GetOpenOrdersRequest request, CancellationToken ct = default);
+
+        /// <summary>
+        /// Spot get closed orders request options
+        /// </summary>
+        PaginatedEndpointOptions<GetClosedOrdersRequest> GetClosedFuturesOrdersOptions { get; }
+        /// <summary>
+        /// Get info on closed futures orders
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="nextPageToken">The pagination token from the previous request to continue pagination</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<ExchangeWebResult<IEnumerable<SharedFuturesOrder>>> GetClosedFuturesOrdersAsync(GetClosedOrdersRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+
+        /// <summary>
+        /// Futures get order trades request options
+        /// </summary>
+        EndpointOptions<GetOrderTradesRequest> GetFuturesOrderTradesOptions { get; }
+        /// <summary>
+        /// Get trades for a specific futures order
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<ExchangeWebResult<IEnumerable<SharedUserTrade>>> GetFuturesOrderTradesAsync(GetOrderTradesRequest request, CancellationToken ct = default);
+
+        /// <summary>
+        /// Futures user trades request options
+        /// </summary>
+        PaginatedEndpointOptions<GetUserTradesRequest> GetFuturesUserTradesOptions { get; }
+        /// <summary>
+        /// Get futures user trade records
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="nextPageToken">The pagination token from the previous request to continue pagination</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<ExchangeWebResult<IEnumerable<SharedUserTrade>>> GetFuturesUserTradesAsync(GetUserTradesRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+
+        /// <summary>
+        /// Futures cancel order request options
+        /// </summary>
+        EndpointOptions<CancelOrderRequest> CancelFuturesOrderOptions { get; }
+        /// <summary>
+        /// Cancel a futures order
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<ExchangeWebResult<SharedId>> CancelFuturesOrderAsync(CancelOrderRequest request, CancellationToken ct = default);
+
+        /// <summary>
+        /// Positions request options
+        /// </summary>
+        EndpointOptions<GetPositionsRequest> GetPositionsOptions { get; }
+        /// <summary>
+        /// Get open position info
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<ExchangeWebResult<IEnumerable<SharedPosition>>> GetPositionsAsync(GetPositionsRequest request, CancellationToken ct = default);
+
+        /// <summary>
+        /// Close position order request options
+        /// </summary>
+        EndpointOptions<ClosePositionRequest> ClosePositionOptions { get; }
+        /// <summary>
+        /// Close a currently open position
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <returns></returns>
+        Task<ExchangeWebResult<SharedId>> ClosePositionAsync(ClosePositionRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/Rest/Futures/IFuturesSymbolRestClient.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for request futures symbol info
+    /// </summary>
+    public interface IFuturesSymbolRestClient : ISharedClient
+    {
+        /// <summary>
+        /// Futures symbol request options
+        /// </summary>
+        EndpointOptions<GetSymbolsRequest> GetFuturesSymbolsOptions { get; }
+        /// <summary>
+        /// Get info on all futures symbols supported on the exchagne
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<ExchangeWebResult<IEnumerable<SharedFuturesSymbol>>> GetFuturesSymbolsAsync(GetSymbolsRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/Rest/Futures/IFuturesTickerRestClient.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for requesting ticker info for futures symbols
+    /// </summary>
+    public interface IFuturesTickerRestClient : ISharedClient
+    {
+        /// <summary>
+        /// Futures get ticker request options
+        /// </summary>
+        EndpointOptions<GetTickerRequest> GetFuturesTickerOptions { get; }
+        /// <summary>
+        /// Get ticker info for a specific futures symbol
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<ExchangeWebResult<SharedFuturesTicker>> GetFuturesTickerAsync(GetTickerRequest request, CancellationToken ct = default);
+
+        /// <summary>
+        /// Futures get tickers request options
+        /// </summary>
+        EndpointOptions<GetTickersRequest> GetFuturesTickersOptions { get; }
+        /// <summary>
+        /// Get ticker info for aall futures symbols
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<ExchangeWebResult<IEnumerable<SharedFuturesTicker>>> GetFuturesTickersAsync(GetTickersRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/Rest/Futures/IIndexPriceKlineRestClient.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for getting the index price klines for a symbol
+    /// </summary>
+    public interface IIndexPriceKlineRestClient : ISharedClient
+    {
+        /// <summary>
+        /// Index price klines request options
+        /// </summary>
+        GetKlinesOptions GetIndexPriceKlinesOptions { get; }
+        /// <summary>
+        /// Get index price kline/candlestick data
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="nextPageToken">The pagination token from the previous request to continue pagination</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<ExchangeWebResult<IEnumerable<SharedFuturesKline>>> GetIndexPriceKlinesAsync(GetKlinesRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+    }
+}