Updated to version 10.7.0

Updated internal lock for subscription to ReaderWriterLockSlim on SocketConnection
Added Http options to Rest client options
2026-08-12 08:53:01 +00:00 · 2026-02-24 11:51:37 +01:00 · 2026-02-24 11:32:35 +01:00 · 2026-02-24 09:58:48 +01:00 · 2026-02-23 14:53:38 +01:00 · 2026-02-22 16:29:05 +01:00
130 changed files with 6659 additions and 1969 deletions
@@ -4,6 +4,7 @@ using NUnit.Framework.Legacy;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;

 namespace CryptoExchange.Net.UnitTests
@@ -139,5 +140,17 @@ namespace CryptoExchange.Net.UnitTests

            ClassicAssert.False(result1);
        }
+
+        [Test]
+        public async Task CancellingWait_Should_ReturnFalse()
+        {
+            var evnt = new AsyncResetEvent(false, true);
+
+            var waiter1 = evnt.WaitAsync(ct: new CancellationTokenSource(50).Token);
+
+            var result1 = await waiter1;
+
+            ClassicAssert.False(result1);
+        }
    }
 }
@@ -19,20 +19,6 @@ namespace CryptoExchange.Net.UnitTests
            Assert.That(result.Success);
        }

-        [TestCase]
-        public void DeserializingInvalidJson_Should_GiveErrorResult()
-        {
-            // arrange
-            var client = new TestBaseClient();
-
-            // act
-            var result = client.SubClient.Deserialize<object>("{\"testProperty\": 123");
-
-            // assert
-            ClassicAssert.IsFalse(result.Success);
-            Assert.That(result.Error != null);
-        }
-
        [TestCase("https://api.test.com/api", new[] { "path1", "path2" }, "https://api.test.com/api/path1/path2")]
        [TestCase("https://api.test.com/api", new[] { "path1", "/path2" }, "https://api.test.com/api/path1/path2")]
        [TestCase("https://api.test.com/api", new[] { "path1/", "path2" }, "https://api.test.com/api/path1/path2")]
@@ -0,0 +1,465 @@
+using CryptoExchange.Net.SharedApis;
+using NUnit.Framework;
+using System;
+using System.Linq;
+
+namespace CryptoExchange.Net.UnitTests
+{
+    [TestFixture()]
+    public class ExchangeSymbolCacheTests
+    {
+        private SharedSpotSymbol[] CreateTestSymbols()
+        {
+            return new[]
+            {
+                new SharedSpotSymbol("BTC", "USDT", "BTCUSDT", true, TradingMode.Spot),
+                new SharedSpotSymbol("ETH", "USDT", "ETHUSDT", true, TradingMode.Spot),
+                new SharedSpotSymbol("BTC", "EUR", "BTCEUR", true, TradingMode.Spot),
+                new SharedSpotSymbol("ETH", "BTC", "ETHBTC", true, TradingMode.Spot),
+                new SharedSpotSymbol("XRP", "USDT", "XRPUSDT", false, TradingMode.Spot)
+            };
+        }
+
+        private SharedSpotSymbol[] CreateFuturesSymbols()
+        {
+            return new[]
+            {
+                new SharedSpotSymbol("BTC", "USDT", "BTCUSDT-PERP", true, TradingMode.PerpetualLinear),
+                new SharedSpotSymbol("ETH", "USDT", "ETHUSDT-PERP", true, TradingMode.PerpetualLinear)
+            };
+        }
+
+        [Test]
+        public void UpdateSymbolInfo_NewTopic_Should_AddToCache()
+        {
+            // arrange
+            var topicId = "NewExchange";
+            var symbols = CreateTestSymbols();
+
+            // act
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+            var hasCached = ExchangeSymbolCache.HasCached(topicId);
+
+            // assert
+            Assert.That(hasCached, Is.True);
+        }
+
+        [Test]
+        public void UpdateSymbolInfo_Should_StoreAllSymbols()
+        {
+            // arrange
+            var topicId = "ExchangeWithSymbols";
+            var symbols = CreateTestSymbols();
+
+            // act
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+
+            // assert
+            Assert.That(ExchangeSymbolCache.SupportsSymbol(topicId, "BTCUSDT"), Is.True);
+            Assert.That(ExchangeSymbolCache.SupportsSymbol(topicId, "ETHUSDT"), Is.True);
+            Assert.That(ExchangeSymbolCache.SupportsSymbol(topicId, "BTCEUR"), Is.True);
+            Assert.That(ExchangeSymbolCache.SupportsSymbol(topicId, "ETHBTC"), Is.True);
+            Assert.That(ExchangeSymbolCache.SupportsSymbol(topicId, "XRPUSDT"), Is.True);
+        }
+
+        [Test]
+        public void UpdateSymbolInfo_CalledTwiceWithinAnHour_Should_NotUpdate()
+        {
+            // arrange
+            var topicId = "ExchangeNoUpdate";
+            var initialSymbols = new[]
+            {
+                new SharedSpotSymbol("BTC", "USDT", "BTCUSDT", true, TradingMode.Spot)
+            };
+            var updatedSymbols = new[]
+            {
+                new SharedSpotSymbol("BTC", "USDT", "BTCUSDT", true, TradingMode.Spot),
+                new SharedSpotSymbol("ETH", "USDT", "ETHUSDT", true, TradingMode.Spot)
+            };
+
+            // act
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, initialSymbols);
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, updatedSymbols);
+
+            // assert - should still have only the initial symbol since less than 60 minutes passed
+            Assert.That(ExchangeSymbolCache.SupportsSymbol(topicId, "BTCUSDT"), Is.True);
+            // The second update should not have been applied
+            Assert.That(ExchangeSymbolCache.SupportsSymbol(topicId, "ETHUSDT"), Is.False);
+        }
+
+        [Test]
+        public void UpdateSymbolInfo_WithEmptyArray_Should_CreateEmptyCache()
+        {
+            // arrange
+            var topicId = "EmptyExchange";
+            var symbols = Array.Empty<SharedSpotSymbol>();
+
+            // act
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+            var hasCached = ExchangeSymbolCache.HasCached(topicId);
+
+            // assert
+            Assert.That(hasCached, Is.False);
+        }
+
+        [Test]
+        public void HasCached_NonExistentTopic_Should_ReturnFalse()
+        {
+            // arrange
+            var nonExistentTopic = "NonExistent_" + Guid.NewGuid();
+
+            // act
+            var result = ExchangeSymbolCache.HasCached(nonExistentTopic);
+
+            // assert
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public void HasCached_ExistingTopicWithSymbols_Should_ReturnTrue()
+        {
+            // arrange
+            var topicId = "ExchangeWithData";
+            var symbols = CreateTestSymbols();
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+
+            // act
+            var result = ExchangeSymbolCache.HasCached(topicId);
+
+            // assert
+            Assert.That(result, Is.True);
+        }
+
+        [Test]
+        public void HasCached_ExistingTopicWithNoSymbols_Should_ReturnFalse()
+        {
+            // arrange
+            var topicId = "ExchangeNoData";
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, Array.Empty<SharedSpotSymbol>());
+
+            // act
+            var result = ExchangeSymbolCache.HasCached(topicId);
+
+            // assert
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public void SupportsSymbol_ByName_ExistingSymbol_Should_ReturnTrue()
+        {
+            // arrange
+            var topicId = "ExchangeSupports";
+            var symbols = CreateTestSymbols();
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+
+            // act
+            var result = ExchangeSymbolCache.SupportsSymbol(topicId, "BTCUSDT");
+
+            // assert
+            Assert.That(result, Is.True);
+        }
+
+        [Test]
+        public void SupportsSymbol_ByName_NonExistingSymbol_Should_ReturnFalse()
+        {
+            // arrange
+            var topicId = "ExchangeNoSupport";
+            var symbols = CreateTestSymbols();
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+
+            // act
+            var result = ExchangeSymbolCache.SupportsSymbol(topicId, "LINKUSDT");
+
+            // assert
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public void SupportsSymbol_ByName_NonExistentTopic_Should_ReturnFalse()
+        {
+            // arrange
+            var nonExistentTopic = "NonExistent_" + Guid.NewGuid();
+
+            // act
+            var result = ExchangeSymbolCache.SupportsSymbol(nonExistentTopic, "BTCUSDT");
+
+            // assert
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public void SupportsSymbol_BySharedSymbol_ExistingSymbol_Should_ReturnTrue()
+        {
+            // arrange
+            var topicId = "ExchangeSharedSymbol";
+            var symbols = CreateTestSymbols();
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+            var sharedSymbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+
+            // act
+            var result = ExchangeSymbolCache.SupportsSymbol(topicId, sharedSymbol);
+
+            // assert
+            Assert.That(result, Is.True);
+        }
+
+        [Test]
+        public void SupportsSymbol_BySharedSymbol_NonExistingSymbol_Should_ReturnFalse()
+        {
+            // arrange
+            var topicId = "ExchangeNoSharedSymbol";
+            var symbols = CreateTestSymbols();
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+            var sharedSymbol = new SharedSymbol(TradingMode.Spot, "LINK", "USDT");
+
+            // act
+            var result = ExchangeSymbolCache.SupportsSymbol(topicId, sharedSymbol);
+
+            // assert
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public void SupportsSymbol_BySharedSymbol_DifferentTradingMode_Should_ReturnFalse()
+        {
+            // arrange
+            var topicId = "ExchangeDifferentMode";
+            var symbols = CreateTestSymbols();
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+            var sharedSymbol = new SharedSymbol(TradingMode.PerpetualLinear, "BTC", "USDT");
+
+            // act
+            var result = ExchangeSymbolCache.SupportsSymbol(topicId, sharedSymbol);
+
+            // assert
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public void SupportsSymbol_BySharedSymbol_NonExistentTopic_Should_ReturnFalse()
+        {
+            // arrange
+            var nonExistentTopic = "NonExistent_" + Guid.NewGuid();
+            var sharedSymbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+
+            // act
+            var result = ExchangeSymbolCache.SupportsSymbol(nonExistentTopic, sharedSymbol);
+
+            // assert
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public void GetSymbolsForBaseAsset_ExistingBaseAsset_Should_ReturnMatchingSymbols()
+        {
+            // arrange
+            var topicId = "ExchangeBaseAsset";
+            var symbols = CreateTestSymbols();
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+
+            // act
+            var result = ExchangeSymbolCache.GetSymbolsForBaseAsset(topicId, "BTC");
+
+            // assert
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Length, Is.EqualTo(2));
+            Assert.That(result.Any(x => x.QuoteAsset == "USDT"), Is.True);
+            Assert.That(result.Any(x => x.QuoteAsset == "EUR"), Is.True);
+        }
+
+        [Test]
+        public void GetSymbolsForBaseAsset_CaseInsensitive_Should_ReturnMatchingSymbols()
+        {
+            // arrange
+            var topicId = "ExchangeCaseInsensitive";
+            var symbols = CreateTestSymbols();
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+
+            // act
+            var result = ExchangeSymbolCache.GetSymbolsForBaseAsset(topicId, "btc");
+
+            // assert
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Length, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void GetSymbolsForBaseAsset_NonExistingBaseAsset_Should_ReturnEmptyArray()
+        {
+            // arrange
+            var topicId = "ExchangeNoBaseAsset";
+            var symbols = CreateTestSymbols();
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+
+            // act
+            var result = ExchangeSymbolCache.GetSymbolsForBaseAsset(topicId, "LINK");
+
+            // assert
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Length, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void GetSymbolsForBaseAsset_NonExistentTopic_Should_ReturnEmptyArray()
+        {
+            // arrange
+            var nonExistentTopic = "NonExistent_" + Guid.NewGuid();
+
+            // act
+            var result = ExchangeSymbolCache.GetSymbolsForBaseAsset(nonExistentTopic, "BTC");
+
+            // assert
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Length, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void ParseSymbol_ExistingSymbol_Should_ReturnSharedSymbol()
+        {
+            // arrange
+            var topicId = "ExchangeParse";
+            var symbols = CreateTestSymbols();
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+
+            // act
+            var result = ExchangeSymbolCache.ParseSymbol(topicId, "BTCUSDT");
+
+            // assert
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.BaseAsset, Is.EqualTo("BTC"));
+            Assert.That(result.QuoteAsset, Is.EqualTo("USDT"));
+            Assert.That(result.TradingMode, Is.EqualTo(TradingMode.Spot));
+            Assert.That(result.SymbolName, Is.EqualTo("BTCUSDT"));
+        }
+
+        [Test]
+        public void ParseSymbol_NonExistingSymbol_Should_ReturnNull()
+        {
+            // arrange
+            var topicId = "ExchangeNoParse";
+            var symbols = CreateTestSymbols();
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+
+            // act
+            var result = ExchangeSymbolCache.ParseSymbol(topicId, "LINKUSDT");
+
+            // assert
+            Assert.That(result, Is.Null);
+        }
+
+        [Test]
+        public void ParseSymbol_NullSymbolName_Should_ReturnNull()
+        {
+            // arrange
+            var topicId = "ExchangeNullSymbol";
+            var symbols = CreateTestSymbols();
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+
+            // act
+            var result = ExchangeSymbolCache.ParseSymbol(topicId, null);
+
+            // assert
+            Assert.That(result, Is.Null);
+        }
+
+        [Test]
+        public void ParseSymbol_NonExistentTopic_Should_ReturnNull()
+        {
+            // arrange
+            var nonExistentTopic = "NonExistent_" + Guid.NewGuid();
+
+            // act
+            var result = ExchangeSymbolCache.ParseSymbol(nonExistentTopic, "BTCUSDT");
+
+            // assert
+            Assert.That(result, Is.Null);
+        }
+
+        [Test]
+        public void MultipleTopics_Should_MaintainSeparateData()
+        {
+            // arrange
+            var topic1 = "Exchange1";
+            var topic2 = "Exchange2";
+            var symbols1 = new[]
+            {
+                new SharedSpotSymbol("BTC", "USDT", "BTCUSDT", true, TradingMode.Spot)
+            };
+            var symbols2 = new[]
+            {
+                new SharedSpotSymbol("ETH", "USDT", "ETHUSDT", true, TradingMode.Spot)
+            };
+
+            // act
+            ExchangeSymbolCache.UpdateSymbolInfo(topic1, symbols1);
+            ExchangeSymbolCache.UpdateSymbolInfo(topic2, symbols2);
+
+            // assert
+            Assert.That(ExchangeSymbolCache.SupportsSymbol(topic1, "BTCUSDT"), Is.True);
+            Assert.That(ExchangeSymbolCache.SupportsSymbol(topic1, "ETHUSDT"), Is.False);
+            Assert.That(ExchangeSymbolCache.SupportsSymbol(topic2, "ETHUSDT"), Is.True);
+            Assert.That(ExchangeSymbolCache.SupportsSymbol(topic2, "BTCUSDT"), Is.False);
+        }
+
+        [Test]
+        public void UpdateSymbolInfo_WithDifferentTradingModes_Should_StoreCorrectly()
+        {
+            // arrange
+            var topicId = "ExchangeMixedModes";
+            var spotSymbols = CreateTestSymbols();
+            var futuresSymbols = CreateFuturesSymbols();
+            var allSymbols = spotSymbols.Concat(futuresSymbols).ToArray();
+
+            // act
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, allSymbols);
+
+            // assert
+            var spotSymbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+            var futuresSymbol = new SharedSymbol(TradingMode.PerpetualLinear, "BTC", "USDT");
+
+            Assert.That(ExchangeSymbolCache.SupportsSymbol(topicId, spotSymbol), Is.True);
+            Assert.That(ExchangeSymbolCache.SupportsSymbol(topicId, futuresSymbol), Is.True);
+        }
+
+        [Test]
+        public void GetSymbolsForBaseAsset_Should_ReturnAllTradingModes()
+        {
+            // arrange
+            var topicId = "ExchangeAllModes";
+            var spotSymbols = CreateTestSymbols();
+            var futuresSymbols = CreateFuturesSymbols();
+            var allSymbols = spotSymbols.Concat(futuresSymbols).ToArray();
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, allSymbols);
+
+            // act
+            var result = ExchangeSymbolCache.GetSymbolsForBaseAsset(topicId, "BTC");
+
+            // assert
+            Assert.That(result.Length, Is.GreaterThanOrEqualTo(2));
+            Assert.That(result.Any(x => x.TradingMode == TradingMode.Spot), Is.True);
+            Assert.That(result.Any(x => x.TradingMode == TradingMode.PerpetualLinear), Is.True);
+        }
+
+        [Test]
+        public void GetSymbolsForBaseAsset_WithMultipleMatchingSymbols_Should_ReturnAll()
+        {
+            // arrange
+            var topicId = "ExchangeMultiple";
+            var symbols = new[]
+            {
+                new SharedSpotSymbol("ETH", "USDT", "ETHUSDT", true, TradingMode.Spot),
+                new SharedSpotSymbol("ETH", "BTC", "ETHBTC", true, TradingMode.Spot),
+                new SharedSpotSymbol("ETH", "EUR", "ETHEUR", true, TradingMode.Spot)
+            };
+            ExchangeSymbolCache.UpdateSymbolInfo(topicId, symbols);
+
+            // act
+            var result = ExchangeSymbolCache.GetSymbolsForBaseAsset(topicId, "ETH");
+
+            // assert
+            Assert.That(result.Length, Is.EqualTo(3));
+            Assert.That(result.All(x => x.BaseAsset == "ETH"), Is.True);
+        }
+
+    }
+}
@@ -81,6 +81,25 @@ namespace CryptoExchange.Net.UnitTests
            Assert.That(result.Error is ServerError);
        }

+
+        [TestCase]
+        public async Task ReceivingErrorAndNotParsingErrorAndInvalidJson_Should_ContainData()
+        {
+            // arrange
+            var client = new TestRestClient();
+            var response = "<html>...</html>";
+            client.SetErrorWithResponse(response, System.Net.HttpStatusCode.BadRequest);
+
+            // act
+            var result = await client.Api1.Request<TestObject>();
+
+            // assert
+            ClassicAssert.IsFalse(result.Success);
+            Assert.That(result.Error != null);
+            Assert.That(result.Error is DeserializeError);
+            Assert.That(result.Error.Message.Contains(response));
+        }
+
        [TestCase]
        public async Task ReceivingErrorAndParsingError_Should_ResultInParsedError()
        {
@@ -0,0 +1,633 @@
+using CryptoExchange.Net.SharedApis;
+using NUnit.Framework;
+using System;
+
+namespace CryptoExchange.Net.UnitTests
+{
+    [TestFixture()]
+    public class SharedQuantityTests
+    {
+        [Test]
+        public void SharedQuantityReference_IsZero_AllNull_Should_ReturnTrue()
+        {
+            // arrange
+            var quantity = new SharedOrderQuantity(null, null, null);
+
+            // act & assert
+            Assert.That(quantity.IsZero, Is.True);
+        }
+
+        [Test]
+        public void SharedQuantityReference_IsZero_AllZero_Should_ReturnTrue()
+        {
+            // arrange
+            var quantity = new SharedOrderQuantity(0, 0, 0);
+
+            // act & assert
+            Assert.That(quantity.IsZero, Is.True);
+        }
+
+        [Test]
+        public void SharedQuantityReference_IsZero_BaseAssetSet_Should_ReturnFalse()
+        {
+            // arrange
+            var quantity = new SharedOrderQuantity(1.5m, null, null);
+
+            // act & assert
+            Assert.That(quantity.IsZero, Is.False);
+        }
+
+        [Test]
+        public void SharedQuantityReference_IsZero_QuoteAssetSet_Should_ReturnFalse()
+        {
+            // arrange
+            var quantity = new SharedOrderQuantity(null, 100m, null);
+
+            // act & assert
+            Assert.That(quantity.IsZero, Is.False);
+        }
+
+        [Test]
+        public void SharedQuantityReference_IsZero_ContractsSet_Should_ReturnFalse()
+        {
+            // arrange
+            var quantity = new SharedOrderQuantity(null, null, 10m);
+
+            // act & assert
+            Assert.That(quantity.IsZero, Is.False);
+        }
+
+        [Test]
+        public void SharedQuantityReference_IsZero_NegativeValue_Should_ReturnTrue()
+        {
+            // arrange
+            var quantity = new SharedOrderQuantity(-1m, 0, 0);
+
+            // act & assert
+            Assert.That(quantity.IsZero, Is.True);
+        }
+
+        [Test]
+        public void SharedQuantity_DefaultConstructor_Should_SetAllPropertiesToNull()
+        {
+            // arrange & act
+            var quantity = new SharedQuantity();
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.Null);
+            Assert.That(quantity.QuantityInQuoteAsset, Is.Null);
+            Assert.That(quantity.QuantityInContracts, Is.Null);
+            Assert.That(quantity.IsZero, Is.True);
+        }
+
+        [Test]
+        public void SharedQuantity_Base_Should_SetBaseAssetQuantity()
+        {
+            // arrange
+            var expectedQuantity = 1.5m;
+
+            // act
+            var quantity = SharedQuantity.Base(expectedQuantity);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(expectedQuantity));
+            Assert.That(quantity.QuantityInQuoteAsset, Is.Null);
+            Assert.That(quantity.QuantityInContracts, Is.Null);
+        }
+
+        [Test]
+        public void SharedQuantity_Base_WithZero_Should_SetZeroQuantity()
+        {
+            // arrange & act
+            var quantity = SharedQuantity.Base(0m);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(0m));
+            Assert.That(quantity.IsZero, Is.True);
+        }
+
+        [Test]
+        public void SharedQuantity_Base_WithLargeValue_Should_SetCorrectly()
+        {
+            // arrange
+            var largeValue = 999999.123456789m;
+
+            // act
+            var quantity = SharedQuantity.Base(largeValue);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(largeValue));
+        }
+
+        [Test]
+        public void SharedQuantity_Quote_Should_SetQuoteAssetQuantity()
+        {
+            // arrange
+            var expectedQuantity = 100m;
+
+            // act
+            var quantity = SharedQuantity.Quote(expectedQuantity);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.Null);
+            Assert.That(quantity.QuantityInQuoteAsset, Is.EqualTo(expectedQuantity));
+            Assert.That(quantity.QuantityInContracts, Is.Null);
+        }
+
+        [Test]
+        public void SharedQuantity_Quote_WithDecimal_Should_PreserveDecimals()
+        {
+            // arrange
+            var expectedQuantity = 50.123456m;
+
+            // act
+            var quantity = SharedQuantity.Quote(expectedQuantity);
+
+            // assert
+            Assert.That(quantity.QuantityInQuoteAsset, Is.EqualTo(expectedQuantity));
+        }
+
+        [Test]
+        public void SharedQuantity_Contracts_Should_SetContractQuantity()
+        {
+            // arrange
+            var expectedQuantity = 10m;
+
+            // act
+            var quantity = SharedQuantity.Contracts(expectedQuantity);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.Null);
+            Assert.That(quantity.QuantityInQuoteAsset, Is.Null);
+            Assert.That(quantity.QuantityInContracts, Is.EqualTo(expectedQuantity));
+        }
+
+        [Test]
+        public void SharedQuantity_Contracts_WithFractionalValue_Should_SetCorrectly()
+        {
+            // arrange
+            var expectedQuantity = 2.5m;
+
+            // act
+            var quantity = SharedQuantity.Contracts(expectedQuantity);
+
+            // assert
+            Assert.That(quantity.QuantityInContracts, Is.EqualTo(expectedQuantity));
+        }
+
+        [Test]
+        public void SharedQuantity_BaseFromQuote_Should_CalculateCorrectly()
+        {
+            // arrange
+            var quoteQuantity = 100m;
+            var price = 50m;
+            var expectedBase = 2m; // 100 / 50 = 2
+
+            // act
+            var quantity = SharedQuantity.BaseFromQuote(quoteQuantity, price);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(expectedBase));
+            Assert.That(quantity.QuantityInQuoteAsset, Is.Null);
+            Assert.That(quantity.QuantityInContracts, Is.Null);
+        }
+
+        [Test]
+        public void SharedQuantity_BaseFromQuote_WithCustomDecimals_Should_RoundCorrectly()
+        {
+            // arrange
+            var quoteQuantity = 100m;
+            var price = 3m;
+            var decimalPlaces = 2;
+
+            // act
+            var quantity = SharedQuantity.BaseFromQuote(quoteQuantity, price, decimalPlaces);
+
+            // assert
+            // 100 / 3 = 33.333... should round to 33.33
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(33.33m));
+        }
+
+        [Test]
+        public void SharedQuantity_BaseFromQuote_WithLotSize_Should_AdjustToLotSize()
+        {
+            // arrange
+            var quoteQuantity = 100m;
+            var price = 7m;
+            var lotSize = 0.1m;
+
+            // act
+            var quantity = SharedQuantity.BaseFromQuote(quoteQuantity, price, 8, lotSize);
+
+            // assert
+            // 100 / 7 = 14.285714... should adjust to nearest 0.1 = 14.3
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(14.3m));
+        }
+
+        [Test]
+        public void SharedQuantity_BaseFromQuote_WithHighPrecision_Should_HandleCorrectly()
+        {
+            // arrange
+            var quoteQuantity = 1000m;
+            var price = 0.00001m;
+            var decimalPlaces = 8;
+
+            // act
+            var quantity = SharedQuantity.BaseFromQuote(quoteQuantity, price, decimalPlaces);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.GreaterThan(0));
+        }
+
+        [Test]
+        public void SharedQuantity_QuoteFromBase_Should_CalculateCorrectly()
+        {
+            // arrange
+            var baseQuantity = 2m;
+            var price = 50m;
+            var expectedQuote = 100m; // 2 * 50 = 100
+
+            // act
+            var quantity = SharedQuantity.QuoteFromBase(baseQuantity, price);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(expectedQuote));
+            Assert.That(quantity.QuantityInQuoteAsset, Is.Null);
+            Assert.That(quantity.QuantityInContracts, Is.Null);
+        }
+
+        [Test]
+        public void SharedQuantity_QuoteFromBase_WithCustomDecimals_Should_RoundCorrectly()
+        {
+            // arrange
+            var baseQuantity = 1.234567m;
+            var price = 10m;
+            var decimalPlaces = 2;
+
+            // act
+            var quantity = SharedQuantity.QuoteFromBase(baseQuantity, price, decimalPlaces);
+
+            // assert
+            // 1.234567 * 10 = 12.34567 should round to 12.35
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(12.35m));
+        }
+
+        [Test]
+        public void SharedQuantity_QuoteFromBase_WithLotSize_Should_AdjustToLotSize()
+        {
+            // arrange
+            var baseQuantity = 3.456m;
+            var price = 10m;
+            var lotSize = 1m;
+
+            // act
+            var quantity = SharedQuantity.QuoteFromBase(baseQuantity, price, 8, lotSize);
+
+            // assert
+            // 3.456 * 10 = 34.56 should adjust to nearest 1 = 35
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(35m));
+        }
+
+        [Test]
+        public void SharedQuantity_QuoteFromBase_WithSmallValues_Should_HandleCorrectly()
+        {
+            // arrange
+            var baseQuantity = 0.001m;
+            var price = 0.1m;
+            var decimalPlaces = 8;
+
+            // act
+            var quantity = SharedQuantity.QuoteFromBase(baseQuantity, price, decimalPlaces);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(0.0001m));
+        }
+
+        [Test]
+        public void SharedQuantity_ContractsFromBase_Should_CalculateCorrectly()
+        {
+            // arrange
+            var baseQuantity = 100m;
+            var contractSize = 10m;
+            var expectedContracts = 10m; // 100 / 10 = 10
+
+            // act
+            var quantity = SharedQuantity.ContractsFromBase(baseQuantity, contractSize);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(expectedContracts));
+            Assert.That(quantity.QuantityInQuoteAsset, Is.Null);
+            Assert.That(quantity.QuantityInContracts, Is.Null);
+        }
+
+        [Test]
+        public void SharedQuantity_ContractsFromBase_WithCustomDecimals_Should_RoundCorrectly()
+        {
+            // arrange
+            var baseQuantity = 100m;
+            var contractSize = 3m;
+            var decimalPlaces = 2;
+
+            // act
+            var quantity = SharedQuantity.ContractsFromBase(baseQuantity, contractSize, decimalPlaces);
+
+            // assert
+            // 100 / 3 = 33.333... should round to 33.33
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(33.33m));
+        }
+
+        [Test]
+        public void SharedQuantity_ContractsFromBase_WithLotSize_Should_AdjustToLotSize()
+        {
+            // arrange
+            var baseQuantity = 100m;
+            var contractSize = 7m;
+            var lotSize = 0.5m;
+
+            // act
+            var quantity = SharedQuantity.ContractsFromBase(baseQuantity, contractSize, 8, lotSize);
+
+            // assert
+            // 100 / 7 = 14.285714... should adjust to nearest 0.5 = 14.5
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(14.5m));
+        }
+
+        [Test]
+        public void SharedQuantity_ContractsFromBase_WithFractionalContract_Should_HandleCorrectly()
+        {
+            // arrange
+            var baseQuantity = 1m;
+            var contractSize = 0.1m;
+
+            // act
+            var quantity = SharedQuantity.ContractsFromBase(baseQuantity, contractSize);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(10m));
+        }
+
+        [Test]
+        public void SharedQuantity_ContractsFromQuote_Should_CalculateCorrectly()
+        {
+            // arrange
+            var quoteQuantity = 1000m;
+            var contractSize = 10m;
+            var price = 50m;
+            var expectedContracts = 2m; // 1000 / 50 / 10 = 2
+
+            // act
+            var quantity = SharedQuantity.ContractsFromQuote(quoteQuantity, contractSize, price);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(expectedContracts));
+            Assert.That(quantity.QuantityInQuoteAsset, Is.Null);
+            Assert.That(quantity.QuantityInContracts, Is.Null);
+        }
+
+        [Test]
+        public void SharedQuantity_ContractsFromQuote_WithCustomDecimals_Should_RoundCorrectly()
+        {
+            // arrange
+            var quoteQuantity = 100m;
+            var contractSize = 3m;
+            var price = 7m;
+            var decimalPlaces = 2;
+
+            // act
+            var quantity = SharedQuantity.ContractsFromQuote(quoteQuantity, contractSize, price, decimalPlaces);
+
+            // assert
+            // 100 / 7 / 3 = 4.761904... should round to 4.76
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(4.76m));
+        }
+
+        [Test]
+        public void SharedQuantity_ContractsFromQuote_WithLotSize_Should_AdjustToLotSize()
+        {
+            // arrange
+            var quoteQuantity = 1000m;
+            var contractSize = 7m;
+            var price = 13m;
+            var lotSize = 0.5m;
+
+            // act
+            var quantity = SharedQuantity.ContractsFromQuote(quoteQuantity, contractSize, price, 8, lotSize);
+
+            // assert
+            // 1000 / 13 / 7 = 10.989... should adjust to nearest 0.5 = 11.0
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(11.0m));
+        }
+
+        [Test]
+        public void SharedQuantity_ContractsFromQuote_WithComplexValues_Should_CalculateCorrectly()
+        {
+            // arrange
+            var quoteQuantity = 5000m;
+            var contractSize = 0.01m;
+            var price = 25000m;
+            var decimalPlaces = 4;
+
+            // act
+            var quantity = SharedQuantity.ContractsFromQuote(quoteQuantity, contractSize, price, decimalPlaces);
+
+            // assert
+            // 5000 / 25000 / 0.01 = 20
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(20m));
+        }
+
+        [Test]
+        public void SharedOrderQuantity_DefaultConstructor_Should_SetAllPropertiesToNull()
+        {
+            // arrange & act
+            var quantity = new SharedOrderQuantity();
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.Null);
+            Assert.That(quantity.QuantityInQuoteAsset, Is.Null);
+            Assert.That(quantity.QuantityInContracts, Is.Null);
+            Assert.That(quantity.IsZero, Is.True);
+        }
+
+        [Test]
+        public void SharedOrderQuantity_ParameterizedConstructor_Should_SetBaseAsset()
+        {
+            // arrange
+            var baseAsset = 5m;
+
+            // act
+            var quantity = new SharedOrderQuantity(baseAssetQuantity: baseAsset);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(baseAsset));
+            Assert.That(quantity.QuantityInQuoteAsset, Is.Null);
+            Assert.That(quantity.QuantityInContracts, Is.Null);
+        }
+
+        [Test]
+        public void SharedOrderQuantity_ParameterizedConstructor_Should_SetQuoteAsset()
+        {
+            // arrange
+            var quoteAsset = 100m;
+
+            // act
+            var quantity = new SharedOrderQuantity(quoteAssetQuantity: quoteAsset);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.Null);
+            Assert.That(quantity.QuantityInQuoteAsset, Is.EqualTo(quoteAsset));
+            Assert.That(quantity.QuantityInContracts, Is.Null);
+        }
+
+        [Test]
+        public void SharedOrderQuantity_ParameterizedConstructor_Should_SetContracts()
+        {
+            // arrange
+            var contracts = 10m;
+
+            // act
+            var quantity = new SharedOrderQuantity(contractQuantity: contracts);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.Null);
+            Assert.That(quantity.QuantityInQuoteAsset, Is.Null);
+            Assert.That(quantity.QuantityInContracts, Is.EqualTo(contracts));
+        }
+
+        [Test]
+        public void SharedOrderQuantity_ParameterizedConstructor_Should_SetAllValues()
+        {
+            // arrange
+            var baseAsset = 1m;
+            var quoteAsset = 50m;
+            var contracts = 5m;
+
+            // act
+            var quantity = new SharedOrderQuantity(baseAsset, quoteAsset, contracts);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.EqualTo(baseAsset));
+            Assert.That(quantity.QuantityInQuoteAsset, Is.EqualTo(quoteAsset));
+            Assert.That(quantity.QuantityInContracts, Is.EqualTo(contracts));
+            Assert.That(quantity.IsZero, Is.False);
+        }
+
+        [Test]
+        public void SharedOrderQuantity_ParameterizedConstructor_WithNullValues_Should_HandleCorrectly()
+        {
+            // arrange & act
+            var quantity = new SharedOrderQuantity(null, null, null);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.Null);
+            Assert.That(quantity.QuantityInQuoteAsset, Is.Null);
+            Assert.That(quantity.QuantityInContracts, Is.Null);
+            Assert.That(quantity.IsZero, Is.True);
+        }
+
+        [Test]
+        public void SharedQuantity_RecordEquality_SameValues_Should_BeEqual()
+        {
+            // arrange
+            var quantity1 = SharedQuantity.Base(10m);
+            var quantity2 = SharedQuantity.Base(10m);
+
+            // act & assert
+            Assert.That(quantity1, Is.EqualTo(quantity2));
+        }
+
+        [Test]
+        public void SharedQuantity_RecordEquality_DifferentValues_Should_NotBeEqual()
+        {
+            // arrange
+            var quantity1 = SharedQuantity.Base(10m);
+            var quantity2 = SharedQuantity.Base(20m);
+
+            // act & assert
+            Assert.That(quantity1, Is.Not.EqualTo(quantity2));
+        }
+
+        [Test]
+        public void SharedQuantity_RecordEquality_DifferentTypes_Should_NotBeEqual()
+        {
+            // arrange
+            var quantity1 = SharedQuantity.Base(10m);
+            var quantity2 = SharedQuantity.Quote(10m);
+
+            // act & assert
+            Assert.That(quantity1, Is.Not.EqualTo(quantity2));
+        }
+
+        [Test]
+        public void SharedOrderQuantity_RecordEquality_SameValues_Should_BeEqual()
+        {
+            // arrange
+            var quantity1 = new SharedOrderQuantity(5m, 100m, 2m);
+            var quantity2 = new SharedOrderQuantity(5m, 100m, 2m);
+
+            // act & assert
+            Assert.That(quantity1, Is.EqualTo(quantity2));
+        }
+
+        [Test]
+        public void SharedQuantity_BaseFromQuote_WithDefaultParameters_Should_UseDefaults()
+        {
+            // arrange
+            var quoteQuantity = 100m;
+            var price = 3m;
+
+            // act
+            var quantity = SharedQuantity.BaseFromQuote(quoteQuantity, price);
+
+            // assert
+            // Default decimalPlaces = 8, default lotSize = 0.00000001
+            Assert.That(quantity.QuantityInBaseAsset, Is.Not.Null);
+            Assert.That(quantity.QuantityInBaseAsset, Is.GreaterThan(0));
+        }
+
+        [Test]
+        public void SharedQuantity_QuoteFromBase_WithDefaultParameters_Should_UseDefaults()
+        {
+            // arrange
+            var baseQuantity = 1.234567m;
+            var price = 10m;
+
+            // act
+            var quantity = SharedQuantity.QuoteFromBase(baseQuantity, price);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.Not.Null);
+            Assert.That(quantity.QuantityInBaseAsset, Is.GreaterThan(0));
+        }
+
+        [Test]
+        public void SharedQuantity_ContractsFromBase_WithDefaultParameters_Should_UseDefaults()
+        {
+            // arrange
+            var baseQuantity = 100m;
+            var contractSize = 3m;
+
+            // act
+            var quantity = SharedQuantity.ContractsFromBase(baseQuantity, contractSize);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.Not.Null);
+            Assert.That(quantity.QuantityInBaseAsset, Is.GreaterThan(0));
+        }
+
+        [Test]
+        public void SharedQuantity_ContractsFromQuote_WithDefaultParameters_Should_UseDefaults()
+        {
+            // arrange
+            var quoteQuantity = 1000m;
+            var contractSize = 10m;
+            var price = 50m;
+
+            // act
+            var quantity = SharedQuantity.ContractsFromQuote(quoteQuantity, contractSize, price);
+
+            // assert
+            Assert.That(quantity.QuantityInBaseAsset, Is.Not.Null);
+            Assert.That(quantity.QuantityInBaseAsset, Is.GreaterThan(0));
+        }
+    }
+}
@@ -0,0 +1,400 @@
+using CryptoExchange.Net.SharedApis;
+using NUnit.Framework;
+using System;
+
+namespace CryptoExchange.Net.UnitTests
+{
+    [TestFixture()]
+    public class SharedSymbolTests
+    {
+        [Test]
+        public void SharedSymbol_Constructor_Should_SetAllProperties()
+        {
+            // arrange
+            var tradingMode = TradingMode.Spot;
+            var baseAsset = "BTC";
+            var quoteAsset = "USDT";
+
+            // act
+            var symbol = new SharedSymbol(tradingMode, baseAsset, quoteAsset);
+
+            // assert
+            Assert.That(symbol.TradingMode, Is.EqualTo(tradingMode));
+            Assert.That(symbol.BaseAsset, Is.EqualTo(baseAsset));
+            Assert.That(symbol.QuoteAsset, Is.EqualTo(quoteAsset));
+            Assert.That(symbol.DeliverTime, Is.Null);
+            Assert.That(symbol.SymbolName, Is.Null);
+        }
+
+        [Test]
+        public void SharedSymbol_Constructor_WithDeliveryTime_Should_SetDeliveryTime()
+        {
+            // arrange
+            var tradingMode = TradingMode.DeliveryLinear;
+            var baseAsset = "BTC";
+            var quoteAsset = "USDT";
+            var deliveryTime = new DateTime(2026, 6, 25, 0, 0, 0, DateTimeKind.Utc);
+
+            // act
+            var symbol = new SharedSymbol(tradingMode, baseAsset, quoteAsset, deliveryTime);
+
+            // assert
+            Assert.That(symbol.TradingMode, Is.EqualTo(tradingMode));
+            Assert.That(symbol.BaseAsset, Is.EqualTo(baseAsset));
+            Assert.That(symbol.QuoteAsset, Is.EqualTo(quoteAsset));
+            Assert.That(symbol.DeliverTime, Is.EqualTo(deliveryTime));
+            Assert.That(symbol.SymbolName, Is.Null);
+        }
+
+        [Test]
+        public void SharedSymbol_Constructor_WithNullDeliveryTime_Should_SetToNull()
+        {
+            // arrange
+            var tradingMode = TradingMode.Spot;
+            var baseAsset = "ETH";
+            var quoteAsset = "BTC";
+
+            // act
+            var symbol = new SharedSymbol(tradingMode, baseAsset, quoteAsset, deliverTime: null);
+
+            // assert
+            Assert.That(symbol.DeliverTime, Is.Null);
+        }
+
+        [TestCase(TradingMode.Spot)]
+        [TestCase(TradingMode.PerpetualLinear)]
+        [TestCase(TradingMode.PerpetualInverse)]
+        [TestCase(TradingMode.DeliveryLinear)]
+        [TestCase(TradingMode.DeliveryInverse)]
+        public void SharedSymbol_Constructor_WithDifferentTradingModes_Should_SetCorrectly(TradingMode tradingMode)
+        {
+            // arrange
+            var baseAsset = "BTC";
+            var quoteAsset = "USDT";
+
+            // act
+            var symbol = new SharedSymbol(tradingMode, baseAsset, quoteAsset);
+
+            // assert
+            Assert.That(symbol.TradingMode, Is.EqualTo(tradingMode));
+        }
+
+        [Test]
+        public void SharedSymbol_ConstructorWithSymbolName_Should_SetSymbolName()
+        {
+            // arrange
+            var tradingMode = TradingMode.Spot;
+            var baseAsset = "BTC";
+            var quoteAsset = "USDT";
+            var symbolName = "BTC-USDT";
+
+            // act
+            var symbol = new SharedSymbol(tradingMode, baseAsset, quoteAsset, symbolName);
+
+            // assert
+            Assert.That(symbol.TradingMode, Is.EqualTo(tradingMode));
+            Assert.That(symbol.BaseAsset, Is.EqualTo(baseAsset));
+            Assert.That(symbol.QuoteAsset, Is.EqualTo(quoteAsset));
+            Assert.That(symbol.SymbolName, Is.EqualTo(symbolName));
+            Assert.That(symbol.DeliverTime, Is.Null);
+        }
+
+        [Test]
+        public void SharedSymbol_ConstructorWithSymbolName_WithCustomFormat_Should_SetCorrectly()
+        {
+            // arrange
+            var tradingMode = TradingMode.PerpetualLinear;
+            var baseAsset = "ETH";
+            var quoteAsset = "USDT";
+            var symbolName = "ETHUSDT-PERP";
+
+            // act
+            var symbol = new SharedSymbol(tradingMode, baseAsset, quoteAsset, symbolName);
+
+            // assert
+            Assert.That(symbol.SymbolName, Is.EqualTo(symbolName));
+        }
+
+        [Test]
+        public void SharedSymbol_ConstructorWithSymbolName_WithEmptyString_Should_SetEmptyString()
+        {
+            // arrange
+            var tradingMode = TradingMode.Spot;
+            var baseAsset = "BTC";
+            var quoteAsset = "USDT";
+            var symbolName = "";
+
+            // act
+            var symbol = new SharedSymbol(tradingMode, baseAsset, quoteAsset, symbolName);
+
+            // assert
+            Assert.That(symbol.SymbolName, Is.EqualTo(""));
+        }
+
+        [Test]
+        public void GetSymbol_WithSymbolNameSet_Should_ReturnSymbolName()
+        {
+            // arrange
+            var symbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT", "CUSTOM-BTC-USDT");
+            var formatFunc = new Func<string, string, TradingMode, DateTime?, string>(
+                (b, q, t, d) => $"{b}{q}");
+
+            // act
+            var result = symbol.GetSymbol(formatFunc);
+
+            // assert
+            Assert.That(result, Is.EqualTo("CUSTOM-BTC-USDT"));
+        }
+
+        [Test]
+        public void GetSymbol_WithSymbolNameNull_Should_UseFormatFunction()
+        {
+            // arrange
+            var symbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+            var formatFunc = new Func<string, string, TradingMode, DateTime?, string>(
+                (b, q, t, d) => $"{b}/{q}");
+
+            // act
+            var result = symbol.GetSymbol(formatFunc);
+
+            // assert
+            Assert.That(result, Is.EqualTo("BTC/USDT"));
+        }
+
+        [Test]
+        public void GetSymbol_WithComplexFormatFunction_Should_ApplyCorrectly()
+        {
+            // arrange
+            var symbol = new SharedSymbol(TradingMode.PerpetualLinear, "ETH", "USDT");
+            var formatFunc = new Func<string, string, TradingMode, DateTime?, string>(
+                (b, q, t, d) => t == TradingMode.PerpetualLinear ? $"{b}{q}-PERP" : $"{b}{q}");
+
+            // act
+            var result = symbol.GetSymbol(formatFunc);
+
+            // assert
+            Assert.That(result, Is.EqualTo("ETHUSDT-PERP"));
+        }
+
+        [Test]
+        public void GetSymbol_WithDeliveryTime_Should_PassDeliveryTimeToFormatter()
+        {
+            // arrange
+            var deliveryTime = new DateTime(2026, 6, 25);
+            var symbol = new SharedSymbol(TradingMode.DeliveryLinear, "BTC", "USDT", deliveryTime);
+            var formatFunc = new Func<string, string, TradingMode, DateTime?, string>(
+                (b, q, t, d) => d.HasValue ? $"{b}{q}_{d.Value:yyyyMMdd}" : $"{b}{q}");
+
+            // act
+            var result = symbol.GetSymbol(formatFunc);
+
+            // assert
+            Assert.That(result, Is.EqualTo("BTCUSDT_20260625"));
+        }
+
+        [Test]
+        public void GetSymbol_WithTradingMode_Should_PassTradingModeToFormatter()
+        {
+            // arrange
+            var symbol = new SharedSymbol(TradingMode.PerpetualInverse, "BTC", "USD");
+            var formatFunc = new Func<string, string, TradingMode, DateTime?, string>(
+                (b, q, t, d) =>
+                {
+                    return t switch
+                    {
+                        TradingMode.Spot => $"{b}{q}",
+                        TradingMode.PerpetualLinear => $"{b}{q}-PERP",
+                        TradingMode.PerpetualInverse => $"{b}{q}I-PERP",
+                        _ => $"{b}{q}"
+                    };
+                });
+
+            // act
+            var result = symbol.GetSymbol(formatFunc);
+
+            // assert
+            Assert.That(result, Is.EqualTo("BTCUSDI-PERP"));
+        }
+
+        [Test]
+        public void GetSymbol_WithEmptySymbolName_Should_UseFormatFunction()
+        {
+            // arrange
+            var symbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT", "");
+            var formatFunc = new Func<string, string, TradingMode, DateTime?, string>(
+                (b, q, t, d) => $"{b}-{q}");
+
+            // act
+            var result = symbol.GetSymbol(formatFunc);
+
+            // assert
+            Assert.That(result, Is.EqualTo("BTC-USDT"));
+        }
+
+        [Test]
+        public void GetSymbol_WithWhitespaceSymbolName_Should_ReturnWhitespace()
+        {
+            // arrange
+            var symbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT", "   ");
+            var formatFunc = new Func<string, string, TradingMode, DateTime?, string>(
+                (b, q, t, d) => $"{b}-{q}");
+
+            // act
+            var result = symbol.GetSymbol(formatFunc);
+
+            // assert
+            Assert.That(result, Is.EqualTo("   "));
+        }
+
+        [Test]
+        public void SharedSymbol_RecordEquality_SameValues_Should_BeEqual()
+        {
+            // arrange
+            var symbol1 = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+            var symbol2 = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+
+            // act & assert
+            Assert.That(symbol1, Is.EqualTo(symbol2));
+        }
+
+        [Test]
+        public void SharedSymbol_RecordEquality_DifferentBaseAsset_Should_NotBeEqual()
+        {
+            // arrange
+            var symbol1 = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+            var symbol2 = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");
+
+            // act & assert
+            Assert.That(symbol1, Is.Not.EqualTo(symbol2));
+        }
+
+        [Test]
+        public void SharedSymbol_RecordEquality_DifferentQuoteAsset_Should_NotBeEqual()
+        {
+            // arrange
+            var symbol1 = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+            var symbol2 = new SharedSymbol(TradingMode.Spot, "BTC", "EUR");
+
+            // act & assert
+            Assert.That(symbol1, Is.Not.EqualTo(symbol2));
+        }
+
+        [Test]
+        public void SharedSymbol_RecordEquality_DifferentTradingMode_Should_NotBeEqual()
+        {
+            // arrange
+            var symbol1 = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+            var symbol2 = new SharedSymbol(TradingMode.PerpetualLinear, "BTC", "USDT");
+
+            // act & assert
+            Assert.That(symbol1, Is.Not.EqualTo(symbol2));
+        }
+
+        [Test]
+        public void SharedSymbol_RecordEquality_DifferentDeliveryTime_Should_NotBeEqual()
+        {
+            // arrange
+            var deliveryTime1 = new DateTime(2026, 6, 25);
+            var deliveryTime2 = new DateTime(2026, 9, 25);
+            var symbol1 = new SharedSymbol(TradingMode.DeliveryLinear, "BTC", "USDT", deliveryTime1);
+            var symbol2 = new SharedSymbol(TradingMode.DeliveryLinear, "BTC", "USDT", deliveryTime2);
+
+            // act & assert
+            Assert.That(symbol1, Is.Not.EqualTo(symbol2));
+        }
+
+        [Test]
+        public void SharedSymbol_RecordEquality_DifferentSymbolName_Should_NotBeEqual()
+        {
+            // arrange
+            var symbol1 = new SharedSymbol(TradingMode.Spot, "BTC", "USDT", "BTCUSDT");
+            var symbol2 = new SharedSymbol(TradingMode.Spot, "BTC", "USDT", "BTC-USDT");
+
+            // act & assert
+            Assert.That(symbol1, Is.Not.EqualTo(symbol2));
+        }
+
+        [Test]
+        public void SharedSymbol_RecordEquality_OneWithSymbolNameOneWithout_Should_NotBeEqual()
+        {
+            // NOTE; although this should probably be equal it's considered not because the SymbolName property isn't equal
+            // Overridding equality to ignore SymbolName would be possible but would break the default record equality behavior and cause confusion
+
+            // arrange
+            var symbol1 = new SharedSymbol(TradingMode.Spot, "BTC", "USDT", "BTCUSDT");
+            var symbol2 = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+
+            // act & assert
+            Assert.That(symbol1, Is.Not.EqualTo(symbol2));
+        }
+
+        [Test]
+        public void SharedSymbol_RecordEquality_WithAllPropertiesSet_Should_BeEqual()
+        {
+            // arrange
+            var deliveryTime = new DateTime(2026, 6, 25);
+            var symbol1 = new SharedSymbol(TradingMode.DeliveryLinear, "BTC", "USDT", deliveryTime)
+            {
+                SymbolName = "BTCUSDT-0625"
+            };
+            var symbol2 = new SharedSymbol(TradingMode.DeliveryLinear, "BTC", "USDT", deliveryTime)
+            {
+                SymbolName = "BTCUSDT-0625"
+            };
+
+            // act & assert
+            Assert.That(symbol1, Is.EqualTo(symbol2));
+        }
+
+        [Test]
+        public void SharedSymbol_Properties_Should_BeSettable()
+        {
+            // arrange
+            var symbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+
+            // act
+            symbol.BaseAsset = "ETH";
+            symbol.QuoteAsset = "EUR";
+            symbol.TradingMode = TradingMode.PerpetualLinear;
+            symbol.SymbolName = "CUSTOM";
+            symbol.DeliverTime = DateTime.UtcNow;
+
+            // assert
+            Assert.That(symbol.BaseAsset, Is.EqualTo("ETH"));
+            Assert.That(symbol.QuoteAsset, Is.EqualTo("EUR"));
+            Assert.That(symbol.TradingMode, Is.EqualTo(TradingMode.PerpetualLinear));
+            Assert.That(symbol.SymbolName, Is.EqualTo("CUSTOM"));
+            Assert.That(symbol.DeliverTime, Is.Not.Null);
+        }
+
+        [Test]
+        public void SharedSymbol_WithSpecialCharactersInAssets_Should_HandleCorrectly()
+        {
+            // arrange
+            var baseAsset = "BTC-123";
+            var quoteAsset = "USDT_2.0";
+
+            // act
+            var symbol = new SharedSymbol(TradingMode.Spot, baseAsset, quoteAsset);
+
+            // assert
+            Assert.That(symbol.BaseAsset, Is.EqualTo(baseAsset));
+            Assert.That(symbol.QuoteAsset, Is.EqualTo(quoteAsset));
+        }
+
+        [Test]
+        public void SharedSymbol_WithLongAssetNames_Should_HandleCorrectly()
+        {
+            // arrange
+            var baseAsset = "VERYLONGASSETNAMEFORTESTING";
+            var quoteAsset = "ANOTHERVERYLONGASSETNAME";
+
+            // act
+            var symbol = new SharedSymbol(TradingMode.Spot, baseAsset, quoteAsset);
+
+            // assert
+            Assert.That(symbol.BaseAsset, Is.EqualTo(baseAsset));
+            Assert.That(symbol.QuoteAsset, Is.EqualTo(quoteAsset));
+        }
+    }
+}
@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using System.Text;
+using System.Text.Json;
 using System.Threading.Tasks;
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Clients;
@@ -51,19 +52,11 @@ namespace CryptoExchange.Net.UnitTests

        public CallResult<T> Deserialize<T>(string data)
        {
-            var stream = new MemoryStream(Encoding.UTF8.GetBytes(data));
-            var accessor = CreateAccessor();
-            var valid = accessor.Read(stream, true).Result;
-            if (!valid)
-                return new CallResult<T>(new ServerError(ErrorInfo.Unknown with { Message = data }));
-            
-            var deserializeResult = accessor.Deserialize<T>();
-            return deserializeResult;
+            return new CallResult<T>(JsonSerializer.Deserialize<T>(data));
        }

        /// <inheritdoc />
        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode futuresType, DateTime? deliverDate = null) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
-        protected override IStreamMessageAccessor CreateAccessor() => new SystemTextJsonStreamMessageAccessor(new System.Text.Json.JsonSerializerOptions());
        protected override IMessageSerializer CreateSerializer() => new SystemTextJsonMessageSerializer(new System.Text.Json.JsonSerializerOptions());
        protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials) => throw new NotImplementedException();
        protected override Task<WebCallResult<DateTime>> GetServerTimestampAsync() => throw new NotImplementedException();
@@ -142,7 +142,6 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
        /// <inheritdoc />
        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode futuresType, DateTime? deliverDate = null) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";

-        protected override IStreamMessageAccessor CreateAccessor() => new SystemTextJsonStreamMessageAccessor(new System.Text.Json.JsonSerializerOptions() { TypeInfoResolver = new TestSerializerContext() });
        protected override IMessageSerializer CreateSerializer() => new SystemTextJsonMessageSerializer(new System.Text.Json.JsonSerializerOptions());

        public async Task<CallResult<T>> Request<T>(CancellationToken ct = default) where T : class
@@ -178,7 +177,6 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
            RequestFactory = new Mock<IRequestFactory>().Object;
        }

-        protected override IStreamMessageAccessor CreateAccessor() => new SystemTextJsonStreamMessageAccessor(new System.Text.Json.JsonSerializerOptions());
        protected override IMessageSerializer CreateSerializer() => new SystemTextJsonMessageSerializer(new System.Text.Json.JsonSerializerOptions());

        /// <inheritdoc />
@@ -19,11 +19,14 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
        private ErrorMapping _errorMapping = new ErrorMapping([]);
        public override JsonSerializerOptions Options => new JsonSerializerOptions();

-        public override ValueTask<Error> ParseErrorResponse(int httpStatusCode, HttpResponseHeaders responseHeaders, Stream responseStream)
+        public override async ValueTask<Error> ParseErrorResponse(int httpStatusCode, HttpResponseHeaders responseHeaders, Stream responseStream)
        {
-            var errorData = JsonSerializer.Deserialize<TestError>(responseStream);
+            var result = await GetJsonDocument(responseStream).ConfigureAwait(false);
+            if (result.Item1 != null)
+                return result.Item1;

-            return new ValueTask<Error>(new ServerError(errorData.ErrorCode, _errorMapping.GetErrorInfo(errorData.ErrorCode.ToString(), errorData.ErrorMessage)));
+            var errorData = result.Item2.Deserialize<TestError>();
+            return new ServerError(errorData.ErrorCode, _errorMapping.GetErrorInfo(errorData.ErrorCode.ToString(), errorData.ErrorMessage));
        }
    }
 }
@@ -518,11 +518,14 @@ namespace CryptoExchange.Net.Authentication
        /// </summary>
        protected DateTime GetTimestamp(SocketApiClient apiClient, bool includeOneSecondOffset = true)
        {
-            var result = TimeProvider.GetTime().Add(TimeOffsetManager.GetSocketOffset(apiClient.ClientName) ?? TimeSpan.Zero)!;
-            if (includeOneSecondOffset)
-                result = result.AddSeconds(-1);
+            var timestamp = TimeProvider.GetTime();
+            if(apiClient.ApiOptions.AutoTimestamp ?? apiClient.ClientOptions.AutoTimestamp)
+                timestamp = timestamp.Add(-TimeOffsetManager.GetSocketOffset(apiClient.ClientName) ?? TimeSpan.Zero)!;

-            return result;
+            if (includeOneSecondOffset)
+                timestamp = timestamp.AddSeconds(-1);
+
+            return timestamp;
        }

        /// <summary>
@@ -13,7 +13,10 @@ namespace CryptoExchange.Net.Clients
    /// </summary>
    public abstract class BaseApiClient : IDisposable, IBaseApiClient
    {
-        private string? _clientName;
+        /// <summary>
+        /// Client name
+        /// </summary>
+        protected string? _clientName;

        /// <summary>
        /// Logger
@@ -39,6 +39,11 @@ namespace CryptoExchange.Net.Clients
        /// </summary>
        public string Exchange { get; }

+        /// <summary>
+        /// Whether client is disposed
+        /// </summary>
+        public bool Disposed { get; private set; }
+
        /// <summary>
        /// Api clients in this client
        /// </summary>
@@ -125,6 +130,8 @@ namespace CryptoExchange.Net.Clients
        /// </summary>
        public virtual void Dispose()
        {
+            Disposed = true;
+
            foreach (var client in ApiClients)
                client.Dispose();
        }
@@ -114,12 +114,6 @@ namespace CryptoExchange.Net.Clients
            RequestFactory.Configure(options, httpClient);
        }

-        /// <summary>
-        /// Create a message accessor instance
-        /// </summary>
-        /// <returns></returns>
-        protected abstract IStreamMessageAccessor CreateAccessor();
-
        /// <summary>
        /// Create a serializer instance
        /// </summary>
@@ -443,23 +437,19 @@ namespace CryptoExchange.Net.Clients
                responseStream = await response.GetResponseStreamAsync(cancellationToken).ConfigureAwait(false);
                string? originalData = null;
                var outputOriginalData = ApiOptions.OutputOriginalData ?? ClientOptions.OutputOriginalData;
-                if (outputOriginalData || MessageHandler.RequiresSeekableStream)
+                if (outputOriginalData || MessageHandler.RequiresSeekableStream || !response.IsSuccessStatusCode)
                {
-                    // If we want to return the original string data from the stream, but still want to process it
-                    // we'll need to copy it as the stream isn't seekable, and thus we can only read it once
-                    var memoryStream = new MemoryStream();
-                    await responseStream.CopyToAsync(memoryStream).ConfigureAwait(false);
-                    using var reader = new StreamReader(memoryStream, Encoding.UTF8, false, 4096, true);
-                    if (outputOriginalData) 
+                    // Create a seekable stream from the response stream if:
+                    // 1. We need to output the original data
+                    // 2. The message handler requires a seekable stream
+                    // 3. The response indicates error and we want to output (part of) the returned data
+                    responseStream = await CopyStreamAsync(responseStream).ConfigureAwait(false);
+                    using var reader = new StreamReader(responseStream, Encoding.UTF8, false, 4096, true);
+                    if (outputOriginalData)
                    {
-                        memoryStream.Position = 0;
                        originalData = await reader.ReadToEndAsync().ConfigureAwait(false);
+                        responseStream.Position = 0;
                    }
-
-                    // Continue processing from the memory stream since the response stream is already read and we can't seek it
-                    responseStream.Close();
-                    memoryStream.Position = 0;
-                    responseStream = memoryStream;
                }

                if (!response.IsSuccessStatusCode && !requestDefinition.TryParseOnNonSuccess)
@@ -485,13 +475,12 @@ namespace CryptoExchange.Net.Clients
                    else
                    {
                        // Handle a 'normal' error response. Can still be either a json error message or some random HTML or other string
-
                        try
                        {
                            error = await MessageHandler.ParseErrorResponse(
-                            (int)response.StatusCode,
-                            response.ResponseHeaders,
-                            responseStream).ConfigureAwait(false);
+                                (int)response.StatusCode,
+                                response.ResponseHeaders,
+                                responseStream).ConfigureAwait(false);
                        }
                        catch (Exception ex)
                        {
@@ -727,7 +716,16 @@ namespace CryptoExchange.Net.Clients
                    return;

                var localTime = DateTime.UtcNow;
-                var result = await GetServerTimestampAsync().ConfigureAwait(false);
+                WebCallResult<DateTime> result;
+                try
+                {
+                    result = await GetServerTimestampAsync().ConfigureAwait(false);
+                }
+                catch (NotImplementedException)
+                {
+                    throw new ArgumentException("AutoTimestamp is not available for this API");
+                }
+
                if (!result)
                {
                    _logger.LogWarning("Failed to determine time offset between client and server, timestamping might fail");
@@ -766,6 +764,15 @@ namespace CryptoExchange.Net.Clients
            }
        }

+        private async Task<Stream> CopyStreamAsync(Stream responseStream)
+        {
+            var memoryStream = new MemoryStream();
+            await responseStream.CopyToAsync(memoryStream).ConfigureAwait(false);
+            responseStream.Close();
+            memoryStream.Position = 0;
+            return memoryStream;
+        }
+
        private bool ShouldCache(RequestDefinition definition)
            => ClientOptions.CachingEnabled
            && definition.Method == HttpMethod.Get
@@ -99,11 +99,6 @@ namespace CryptoExchange.Net.Clients
        /// </summary>
        protected bool AllowTopicsOnTheSameConnection { get; set; } = true;

-        /// <summary>
-        /// Whether to continue processing and forward unparsable messages to handlers
-        /// </summary>
-        protected internal bool ProcessUnparsableMessages { get; set; } = false;
-
        /// <inheritdoc />
        public double IncomingKbps
        {
@@ -165,12 +160,6 @@ namespace CryptoExchange.Net.Clients
        {
        }

-        /// <summary>
-        /// Create a message accessor instance
-        /// </summary>
-        /// <returns></returns>
-        protected internal abstract IByteMessageAccessor CreateAccessor(WebSocketMessageType messageType);
-
        /// <summary>
        /// Create a serializer instance
        /// </summary>
@@ -315,52 +304,9 @@ namespace CryptoExchange.Net.Clients
                return new CallResult<UpdateSubscription>(new ServerError(new ErrorInfo(ErrorType.WebsocketPaused, "Socket is paused")));
            }

-            void HandleSubscriptionComplete(bool success, object? response)
-            {
-                if (!success)
-                    return;
-
-                subscription.HandleSubQueryResponse(socketConnection, response);
-                subscription.Status = SubscriptionStatus.Subscribed;
-                if (ct != default)
-                {
-                    subscription.CancellationTokenRegistration = ct.Register(async () =>
-                    {
-                        _logger.CancellationTokenSetClosingSubscription(socketConnection.SocketId, subscription.Id);
-                        await socketConnection.CloseAsync(subscription).ConfigureAwait(false);
-                    }, false);
-                }
-            }
-
-            subscription.Status = SubscriptionStatus.Subscribing;
-            var subQuery = subscription.CreateSubscriptionQuery(socketConnection);
-            if (subQuery != null)
-            {
-                subQuery.OnComplete = () => HandleSubscriptionComplete(subQuery.Result?.Success ?? false, subQuery.Response);
-
-                // Send the request and wait for answer
-                var subResult = await socketConnection.SendAndWaitQueryAsync(subQuery, ct).ConfigureAwait(false);
-                if (!subResult)
-                {
-                    var isTimeout = subResult.Error is CancellationRequestedError;
-                    if (isTimeout && subscription.Status == SubscriptionStatus.Subscribed)
-                    {
-                        // No response received, but the subscription did receive updates. We'll assume success
-                    }
-                    else
-                    {
-                        _logger.FailedToSubscribe(socketConnection.SocketId, subResult.Error?.ToString());
-                        // If this was a server process error we still might need to send an unsubscribe to prevent messages coming in later
-                        subscription.Status = SubscriptionStatus.Pending;
-                        await socketConnection.CloseAsync(subscription).ConfigureAwait(false);
-                        return new CallResult<UpdateSubscription>(subResult.Error!);
-                    }
-                }
-            }
-            else 
-            {
-                HandleSubscriptionComplete(true, null);
-            }
+            var subscribeResult = await socketConnection.TrySubscribeAsync(subscription, true, ct).ConfigureAwait(false);
+            if (!subscribeResult)
+                return new CallResult<UpdateSubscription>(subscribeResult.Error!);

            _logger.SubscriptionCompletedSuccessfully(socketConnection.SocketId, subscription.Id);
            return new CallResult<UpdateSubscription>(new UpdateSubscription(socketConnection, subscription));
@@ -751,7 +697,6 @@ namespace CryptoExchange.Net.Clients

            // Create new socket connection
            var socketConnection = new SocketConnection(_logger, SocketFactory, GetWebSocketParameters(connectionAddress.Data!), this, address);
-            socketConnection.UnhandledMessage += HandleUnhandledMessage;
            socketConnection.ConnectRateLimitedAsync += HandleConnectRateLimitedAsync;
            if (dedicatedRequestConnection)
            {
@@ -802,14 +747,13 @@ namespace CryptoExchange.Net.Clients
            return new CallResult<HighPerfSocketConnection<TUpdateType>>(socketConnection);
        }

-
        /// <summary>
        /// Process an unhandled message
        /// </summary>
-        /// <param name="message">The message that wasn't processed</param>
-        protected virtual void HandleUnhandledMessage(IMessageAccessor message)
-        {
-        }
+        /// <param name="connection">The socket connection</param>
+        /// <param name="typeIdentifier">The type as identified</param>
+        /// <param name="data">The data</param>
+        protected internal virtual bool HandleUnhandledMessage(SocketConnection connection, string typeIdentifier, ReadOnlySpan<byte> data) => false;

        /// <summary>
        /// Process connect rate limited
@@ -863,7 +807,6 @@ namespace CryptoExchange.Net.Clients
                Proxy = ClientOptions.Proxy,
                Timeout = ApiOptions.SocketNoDataTimeout ?? ClientOptions.SocketNoDataTimeout,
                ReceiveBufferSize = ClientOptions.ReceiveBufferSize,
-                UseUpdatedDeserialization = ClientOptions.UseUpdatedDeserialization
            };

        /// <summary>
@@ -1056,7 +999,6 @@ namespace CryptoExchange.Net.Clients
                            sb.AppendLine($"\t\t\tId: {subState.Id}");
                            sb.AppendLine($"\t\t\tStatus: {subState.Status}");
                            sb.AppendLine($"\t\t\tInvocations: {subState.Invocations}");
-                            sb.AppendLine($"\t\t\tIdentifiers: [{subState.ListenMatcher.ToString()}]");
                        });
                    }
                });
@@ -1087,21 +1029,10 @@ namespace CryptoExchange.Net.Clients
            base.Dispose();
        }

-        /// <summary>
-        /// Get the listener identifier for the message
-        /// </summary>
-        /// <param name="messageAccessor"></param>
-        /// <returns></returns>
-        public abstract string? GetListenerIdentifier(IMessageAccessor messageAccessor);
-
        /// <summary>
        /// Preprocess a stream message
        /// </summary>
        public virtual ReadOnlySpan<byte> PreprocessStreamMessage(SocketConnection connection, WebSocketMessageType type, ReadOnlySpan<byte> data) => data;
-        /// <summary>
-        /// Preprocess a stream message
-        /// </summary>
-        public virtual ReadOnlyMemory<byte> PreprocessStreamMessage(SocketConnection connection, WebSocketMessageType type, ReadOnlyMemory<byte> data) => data;

        /// <summary>
        /// Create a new message converter instance
@@ -1,49 +0,0 @@
-namespace CryptoExchange.Net.Converters.MessageParsing
-{
-    /// <summary>
-    /// Node accessor
-    /// </summary>
-    public readonly struct NodeAccessor
-    {
-        /// <summary>
-        /// Index
-        /// </summary>
-        public int? Index { get; }
-        /// <summary>
-        /// Property name
-        /// </summary>
-        public string? Property { get; }
-
-        /// <summary>
-        /// Type (0 = int, 1 = string, 2 = prop name)
-        /// </summary>
-        public int Type { get; }
-
-        private NodeAccessor(int? index, string? property, int type)
-        {
-            Index = index;
-            Property = property;
-            Type = type;
-        }
-
-        /// <summary>
-        /// Create an int node accessor
-        /// </summary>
-        /// <param name="value"></param>
-        /// <returns></returns>
-        public static NodeAccessor Int(int value) { return new NodeAccessor(value, null, 0); }
-
-        /// <summary>
-        /// Create a string node accessor
-        /// </summary>
-        /// <param name="value"></param>
-        /// <returns></returns>
-        public static NodeAccessor String(string value) { return new NodeAccessor(null, value, 1); }
-
-        /// <summary>
-        /// Create a property name node accessor
-        /// </summary>
-        /// <returns></returns>
-        public static NodeAccessor PropertyName() { return new NodeAccessor(null, null, 2); }
-    }
-}
@@ -1,50 +0,0 @@
-using System.Collections;
-using System.Collections.Generic;
-
-namespace CryptoExchange.Net.Converters.MessageParsing
-{
-    /// <summary>
-    /// Message access definition
-    /// </summary>
-    public readonly struct MessagePath : IEnumerable<NodeAccessor>
-    {
-        private readonly List<NodeAccessor> _path;
-
-        internal void Add(NodeAccessor node)
-        {
-            _path.Add(node);
-        }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public MessagePath()
-        {
-            _path = new List<NodeAccessor>();
-        }
-
-        /// <summary>
-        /// Create a new message path
-        /// </summary>
-        /// <returns></returns>
-        public static MessagePath Get()
-        {
-            return new MessagePath();
-        }
-
-        /// <summary>
-        /// IEnumerable implementation
-        /// </summary>
-        /// <returns></returns>
-        public IEnumerator<NodeAccessor> GetEnumerator()
-        {
-            for (var i = 0; i < _path.Count; i++)
-                yield return _path[i];
-        }
-
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return GetEnumerator();
-        }
-    }
-}
@@ -1,43 +0,0 @@
-namespace CryptoExchange.Net.Converters.MessageParsing
-{
-    /// <summary>
-    /// Message path extension methods
-    /// </summary>
-    public static class MessagePathExtension
-    {
-        /// <summary>
-        /// Add a string node accessor
-        /// </summary>
-        /// <param name="path"></param>
-        /// <param name="propName"></param>
-        /// <returns></returns>
-        public static MessagePath Property(this MessagePath path, string propName)
-        {
-            path.Add(NodeAccessor.String(propName));
-            return path;
-        }
-
-        /// <summary>
-        /// Add a property name node accessor
-        /// </summary>
-        /// <param name="path"></param>
-        /// <returns></returns>
-        public static MessagePath PropertyName(this MessagePath path)
-        {
-            path.Add(NodeAccessor.PropertyName());
-            return path;
-        }
-
-        /// <summary>
-        /// Add a int node accessor
-        /// </summary>
-        /// <param name="path"></param>
-        /// <param name="index"></param>
-        /// <returns></returns>
-        public static MessagePath Index(this MessagePath path, int index)
-        {
-            path.Add(NodeAccessor.Int(index));
-            return path;
-        }
-    }
-}
@@ -1,21 +0,0 @@
-namespace CryptoExchange.Net.Converters.MessageParsing
-{
-    /// <summary>
-    /// Message node type
-    /// </summary>
-    public enum NodeType
-    {
-        /// <summary>
-        /// Array node
-        /// </summary>
-        Array,
-        /// <summary>
-        /// Object node
-        /// </summary>
-        Object,
-        /// <summary>
-        /// Value node
-        /// </summary>
-        Value
-    }
-}
@@ -0,0 +1,30 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// Converter for comma separated string values
+    /// </summary>
+    public class CommaSplitStringConverter : JsonConverter<string[]>
+    {
+        /// <inheritdoc />
+        public override string[]? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            var str = reader.GetString();
+            if (string.IsNullOrEmpty(str))
+                return [];
+
+            return str!.Split(',').ToArray() ?? [];
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, string[] value, JsonSerializerOptions options)
+        {
+            writer.WriteStringValue(string.Join(",", value));
+        }
+    }
+}
@@ -168,7 +168,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                    if (!_unknownValuesWarned.Contains(stringValue))
                    {
                        _unknownValuesWarned.Add(stringValue!);
-                        LibraryHelpers.StaticLogger?.LogWarning($"Cannot map enum value. EnumType: {enumType.FullName}, Value: {stringValue}, Known values: {string.Join(", ", _mappingToEnum!.Select(m => m.Value))}. If you think {stringValue} should added please open an issue on the Github repo");
+                        LibraryHelpers.StaticLogger?.LogWarning($"Cannot map enum value. EnumType: {enumType.FullName}, Value: {stringValue}, Known values: [{string.Join(", ", _mappingToEnum!.Select(m => $"{m.StringValue}: {m.Value}"))}]. If you think {stringValue} should added please open an issue on the Github repo");
                    }
                }

@@ -246,6 +246,12 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
            {
                // If no explicit mapping is found try to parse string
                result = (T)Enum.Parse(objectType, value, true);
+                if (!Enum.IsDefined(objectType, result))
+                {
+                    result = default;
+                    return false;
+                }
+
                return true;
            }
            catch (Exception)
@@ -18,6 +18,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers
    public abstract class JsonRestMessageHandler : IRestMessageHandler
    {
        private static MediaTypeWithQualityHeaderValue _acceptJsonContent = new MediaTypeWithQualityHeaderValue(Constants.JsonContentHeader);
+        private const int _errorResponseSnippetLimit = 128;

        /// <summary>
        /// Empty rate limit error
@@ -80,7 +81,20 @@ namespace CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers
            }
            catch (Exception ex)
            {
-                return (new ServerError(new ErrorInfo(ErrorType.DeserializationFailed, false, "Deserialization failed, invalid JSON"), ex), null);
+                var errorMsg = "Deserialization failed, invalid JSON";
+                if (stream.CanSeek)
+                {
+                    var dataSnippet = new char[_errorResponseSnippetLimit];
+                    stream.Seek(0, SeekOrigin.Begin);
+                    var written = new StreamReader(stream).ReadBlock(dataSnippet, 0, _errorResponseSnippetLimit);
+                    var data = new string(dataSnippet, 0, written);
+                    errorMsg += $": {data}";
+                    if (data.Length == _errorResponseSnippetLimit)
+                        errorMsg += " (truncated)";
+                }
+
+                var error = new DeserializeError(errorMsg, ex);
+                return (error, null);
            }
        }

@@ -165,6 +165,14 @@ namespace CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers
            return null;
        }

+        /// <summary>
+        /// Return type identifier for non-json messages
+        /// </summary>
+        protected virtual string? GetTypeIdentifierNonJson(ReadOnlySpan<byte> data, WebSocketMessageType? webSocketMessageType)
+        {
+            return null;
+        }
+
        /// <inheritdoc />
        public virtual string? GetTypeIdentifier(ReadOnlySpan<byte> data, WebSocketMessageType? webSocketMessageType)
        {
@@ -173,6 +181,12 @@ namespace CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers
            int? arrayIndex = null;

            _searchResult.Clear();
+            if (data[0] != 0x5B && data[0] != 0x7B)
+            {
+                // Message doesn't start with `{` or `[`, not valid for processing as json
+                return GetTypeIdentifierNonJson(data, webSocketMessageType);
+            }
+
            var reader = new Utf8JsonReader(data);
            while (reader.Read())
            {
@@ -1,373 +0,0 @@
-using CryptoExchange.Net.Converters.MessageParsing;
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Objects;
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Text;
-using System.Text.Json;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.Converters.SystemTextJson
-{
-    /// <summary>
-    /// System.Text.Json message accessor
-    /// </summary>
-    public abstract class SystemTextJsonMessageAccessor : IMessageAccessor
-    {
-        /// <summary>
-        /// The JsonDocument loaded
-        /// </summary>
-        protected JsonDocument? _document;
-
-        private readonly JsonSerializerOptions? _customSerializerOptions;
-
-        /// <inheritdoc />
-        public bool IsValid { get; set; }
-
-        /// <inheritdoc />
-        public abstract bool OriginalDataAvailable { get; }
-
-        /// <inheritdoc />
-        public object? Underlying => throw new NotImplementedException();
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public SystemTextJsonMessageAccessor(JsonSerializerOptions options)
-        {
-            _customSerializerOptions = options;
-        }
-
-        /// <inheritdoc />
-#if NET5_0_OR_GREATER
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL3050:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-#endif
-        public CallResult<object> Deserialize(Type type, MessagePath? path = null)
-        {
-            if (!IsValid)
-                return new CallResult<object>(GetOriginalString());
-
-            if (_document == null)
-                throw new InvalidOperationException("No json document loaded");
-
-            try
-            {
-                var result = _document.Deserialize(type, _customSerializerOptions);
-                return new CallResult<object>(result!);
-            }
-            catch (JsonException ex)
-            {
-                var info = $"Json deserialization failed: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
-                return new CallResult<object>(new DeserializeError(info, ex));
-            }
-            catch (Exception ex)
-            {
-                return new CallResult<object>(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
-            }
-        }
-
-        /// <inheritdoc />
-#if NET5_0_OR_GREATER
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL3050:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-#endif
-        public CallResult<T> Deserialize<T>(MessagePath? path = null)
-        {
-            if (_document == null)
-                throw new InvalidOperationException("No json document loaded");
-
-            try
-            {
-                var result = _document.Deserialize<T>(_customSerializerOptions);
-                return new CallResult<T>(result!);
-            }
-            catch (JsonException ex)
-            {
-                var info = $"Json deserialization failed: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
-                return new CallResult<T>(new DeserializeError(info, ex));
-            }
-            catch (Exception ex)
-            {
-                return new CallResult<T>(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
-            }
-        }
-
-        /// <inheritdoc />
-        public NodeType? GetNodeType()
-        {
-            if (!IsValid)
-                throw new InvalidOperationException("Can't access json data on non-json message");
-
-            if (_document == null)
-                throw new InvalidOperationException("No json document loaded");
-
-            return _document.RootElement.ValueKind switch
-            {
-                JsonValueKind.Object => NodeType.Object,
-                JsonValueKind.Array => NodeType.Array,
-                _ => NodeType.Value
-            };
-        }
-
-        /// <inheritdoc />
-        public NodeType? GetNodeType(MessagePath path)
-        {
-            if (!IsValid)
-                throw new InvalidOperationException("Can't access json data on non-json message");
-
-            var node = GetPathNode(path);
-            if (!node.HasValue)
-                return null;
-
-            return node.Value.ValueKind switch
-            {
-                JsonValueKind.Object => NodeType.Object,
-                JsonValueKind.Array => NodeType.Array,
-                _ => NodeType.Value
-            };
-        }
-
-        /// <inheritdoc />
-#if NET5_0_OR_GREATER
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL3050:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-#endif
-        public T? GetValue<T>(MessagePath path)
-        {
-            if (!IsValid)
-                throw new InvalidOperationException("Can't access json data on non-json message");
-
-            var value = GetPathNode(path);
-            if (value == null)
-                return default;
-
-            if (value.Value.ValueKind == JsonValueKind.Object || value.Value.ValueKind == JsonValueKind.Array)
-            {
-                try
-                {
-                    return value.Value.Deserialize<T>(_customSerializerOptions);
-                }
-                catch { }
-
-                return default;
-            }
-
-            if (typeof(T) == typeof(string))
-            {
-                if (value.Value.ValueKind == JsonValueKind.Number)
-                    return (T)(object)value.Value.GetInt64().ToString();
-            }
-
-            return value.Value.Deserialize<T>(_customSerializerOptions);
-        }
-
-        /// <inheritdoc />
-#if NET5_0_OR_GREATER
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL3050:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-#endif
-        public T?[]? GetValues<T>(MessagePath path)
-        {
-            if (!IsValid)
-                throw new InvalidOperationException("Can't access json data on non-json message");
-
-            var value = GetPathNode(path);
-            if (value == null)
-                return default;
-
-            if (value.Value.ValueKind != JsonValueKind.Array)
-                return default;
-
-            return value.Value.Deserialize<T[]>(_customSerializerOptions)!;
-        }
-
-        private JsonElement? GetPathNode(MessagePath path)
-        {
-            if (!IsValid)
-                throw new InvalidOperationException("Can't access json data on non-json message");
-
-            if (_document == null)
-                throw new InvalidOperationException("No json document loaded");
-
-            JsonElement? currentToken = _document.RootElement;
-            foreach (var node in path)
-            {
-                if (node.Type == 0)
-                {
-                    // Int value
-                    var val = node.Index!.Value;
-                    if (currentToken!.Value.ValueKind != JsonValueKind.Array || currentToken.Value.GetArrayLength() <= val)
-                        return null;
-
-                    currentToken = currentToken.Value[val];
-                }
-                else if (node.Type == 1)
-                {
-                    // String value
-                    if (currentToken!.Value.ValueKind != JsonValueKind.Object)
-                        return null;
-
-                    if (!currentToken.Value.TryGetProperty(node.Property!, out var token))
-                        return null;
-                    currentToken = token;
-                }
-                else
-                {
-                    // Property name
-                    if (currentToken!.Value.ValueKind != JsonValueKind.Object)
-                        return null;
-
-                    throw new NotImplementedException();
-                }
-
-                if (currentToken == null)
-                    return null;
-            }
-
-            return currentToken;
-        }
-
-        /// <inheritdoc />
-        public abstract string GetOriginalString();
-
-        /// <inheritdoc />
-        public abstract void Clear();
-    }
-
-    /// <summary>
-    /// System.Text.Json stream message accessor
-    /// </summary>
-    public class SystemTextJsonStreamMessageAccessor : SystemTextJsonMessageAccessor, IStreamMessageAccessor
-    {
-        private Stream? _stream;
-
-        /// <inheritdoc />
-        public override bool OriginalDataAvailable => _stream?.CanSeek == true;
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public SystemTextJsonStreamMessageAccessor(JsonSerializerOptions options): base(options)
-        {
-        }
-
-        /// <inheritdoc />
-        public async Task<CallResult> Read(Stream stream, bool bufferStream)
-        {
-            if (bufferStream && stream is not MemoryStream)
-            {
-                // We need to be buffer the stream, and it's not currently a seekable stream, so copy it to a new memory stream
-                _stream = new MemoryStream();
-                stream.CopyTo(_stream);
-                _stream.Position = 0;
-            }
-            else if (bufferStream)
-            {
-                // We need to buffer the stream, and the current stream is seekable, store as is
-                _stream = stream;
-            }
-            else
-            {
-                // We don't need to buffer the stream, so don't bother keeping the reference
-            }
-
-            try
-            {
-                _document = await JsonDocument.ParseAsync(_stream ?? stream).ConfigureAwait(false);
-                IsValid = true;
-                return CallResult.SuccessResult;
-            }
-            catch (Exception ex)
-            {
-                // Not a json message
-                IsValid = false;
-                return new CallResult(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
-            }
-        }
-
-        /// <inheritdoc />
-        public override string GetOriginalString()
-        {
-            if (_stream is null)
-                throw new NullReferenceException("Stream not initialized");
-
-            _stream.Position = 0;
-            using var textReader = new StreamReader(_stream, Encoding.UTF8, false, 1024, true);
-            return textReader.ReadToEnd();
-        }
-
-        /// <inheritdoc />
-        public override void Clear()
-        {
-            _stream?.Dispose();
-            _stream = null;
-            _document?.Dispose();
-            _document = null;
-        }
-
-    }
-
-    /// <summary>
-    /// System.Text.Json byte message accessor
-    /// </summary>
-    public class SystemTextJsonByteMessageAccessor : SystemTextJsonMessageAccessor, IByteMessageAccessor
-    {
-        private ReadOnlyMemory<byte> _bytes;
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public SystemTextJsonByteMessageAccessor(JsonSerializerOptions options) : base(options)
-        {
-        }
-
-        /// <inheritdoc />
-        public CallResult Read(ReadOnlyMemory<byte> data)
-        {
-            _bytes = data;
-
-            try
-            {
-                var firstByte = data.Span[0];
-                if (firstByte != 0x7b && firstByte != 0x5b)
-                {
-                    // Value doesn't start with `{` or `[`, prevent deserialization attempt as it's slow
-                    IsValid = false;
-                    return new CallResult(new DeserializeError("Not a json value"));
-                }
-
-                _document = JsonDocument.Parse(data);
-                IsValid = true;
-                return CallResult.SuccessResult;
-            }
-            catch (Exception ex)
-            {
-                // Not a json message
-                IsValid = false;
-                return new CallResult(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
-            }
-        }
-
-        /// <inheritdoc />
-        public override string GetOriginalString() =>
-            // NetStandard 2.0 doesn't support GetString from a ReadonlySpan<byte>, so use ToArray there instead
-#if NETSTANDARD2_0
-            Encoding.UTF8.GetString(_bytes.ToArray());
-#else
-            Encoding.UTF8.GetString(_bytes.Span);
-#endif
-
-        /// <inheritdoc />
-        public override bool OriginalDataAvailable => true;
-
-        /// <inheritdoc />
-        public override void Clear()
-        {
-            _bytes = null;
-            _document?.Dispose();
-            _document = null;
-        }
-    }
-}
@@ -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>10.2.2</PackageVersion>
-    <AssemblyVersion>10.2.2</AssemblyVersion>
-    <FileVersion>10.2.2</FileVersion>
+    <PackageVersion>10.7.0</PackageVersion>
+    <AssemblyVersion>10.7.0</AssemblyVersion>
+    <FileVersion>10.7.0</FileVersion>
    <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
    <PackageTags>OKX;OKX.Net;Mexc;Mexc.Net;Kucoin;Kucoin.Net;Kraken;Kraken.Net;Huobi;Huobi.Net;CoinEx;CoinEx.Net;Bybit;Bybit.Net;Bitget;Bitget.Net;Bitfinex;Bitfinex.Net;Binance;Binance.Net;CryptoCurrency;CryptoCurrency Exchange;CryptoExchange.Net</PackageTags>
    <RepositoryType>git</RepositoryType>
@@ -4,6 +4,7 @@ using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Security.Cryptography;
 using System.Threading;
@@ -310,11 +311,11 @@ namespace CryptoExchange.Net
        /// <param name="request">The request parameters</param>
        /// <param name="ct">Cancellation token</param>
        /// <returns></returns>
-        public static async IAsyncEnumerable<ExchangeWebResult<T[]>> ExecutePages<T, U>(Func<U, INextPageToken?, CancellationToken, Task<ExchangeWebResult<T[]>>> paginatedFunc, U request, [EnumeratorCancellation]CancellationToken ct = default)
+        public static async IAsyncEnumerable<ExchangeWebResult<T[]>> ExecutePages<T, U>(Func<U, PageRequest?, CancellationToken, Task<ExchangeWebResult<T[]>>> paginatedFunc, U request, [EnumeratorCancellation]CancellationToken ct = default)
        {
            var result = new List<T>();
            ExchangeWebResult<T[]> batch;
-            INextPageToken? nextPageToken = null;
+            PageRequest? nextPageToken = null;
            while (true)
            {
                batch = await paginatedFunc(request, nextPageToken, ct).ConfigureAwait(false);
@@ -323,12 +324,42 @@ namespace CryptoExchange.Net
                    break;

                result.AddRange(batch.Data);
-                nextPageToken = batch.NextPageToken;
+                nextPageToken = batch.NextPageRequest;
                if (nextPageToken == null)
                    break;
            }
        }

+        /// <summary>
+        /// Apply filters to the data set
+        /// </summary>
+        /// <typeparam name="T">Type</typeparam>
+        /// <param name="data">Data set</param>
+        /// <param name="timeSelector">Time selector for the data</param>
+        /// <param name="startTime">Start time filter</param>
+        /// <param name="endTime">End time filter</param>
+        /// <param name="direction">Data direction</param>
+        public static IEnumerable<T> ApplyFilter<T>(
+            IEnumerable<T> data,
+            Func<T, DateTime> timeSelector,
+            DateTime? startTime,
+            DateTime? endTime,
+            DataDirection direction)
+        {
+            if (direction == DataDirection.Ascending)
+                data = data.OrderBy(timeSelector);
+            else
+                data = data.OrderByDescending(timeSelector);
+
+            if (startTime != null)
+                data = data.Where(x => timeSelector(x) >= startTime.Value);
+
+            if (endTime != null)
+                data = data.Where(x => timeSelector(x) < endTime.Value);
+
+            return data;
+        }
+
        /// <summary>
        /// Apply the rules (price and quantity step size and decimals precision, min/max quantity) from the symbol to the quantity and price
        /// </summary>
@@ -32,6 +32,66 @@ namespace CryptoExchange.Net
            _symbolInfos[topicId] = new ExchangeInfo(DateTime.UtcNow, updateData.ToDictionary(x => x.Name, x => x.SharedSymbol));
        }

+        /// <summary>
+        /// Whether the specific topic has been cached
+        /// </summary>
+        /// <param name="topicId">Id</param>
+        public static bool HasCached(string topicId)
+        {
+            if (!_symbolInfos.TryGetValue(topicId, out var exchangeInfo))
+                return false;
+
+            return exchangeInfo.Symbols.Count > 0;
+        }
+
+        /// <summary>
+        /// Whether a specific exchange(topic) support the provided symbol
+        /// </summary>
+        /// <param name="topicId">Id for the provided data</param>
+        /// <param name="symbolName">The symbol name</param>
+        public static bool SupportsSymbol(string topicId, string symbolName)
+        {
+            if (!_symbolInfos.TryGetValue(topicId, out var exchangeInfo))
+                return false;
+
+            if (!exchangeInfo.Symbols.TryGetValue(symbolName, out var symbolInfo))
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Whether a specific exchange(topic) support the provided symbol
+        /// </summary>
+        /// <param name="topicId">Id for the provided data</param>
+        /// <param name="symbol">The symbol info</param>
+        public static bool SupportsSymbol(string topicId, SharedSymbol symbol)
+        {
+            if (!_symbolInfos.TryGetValue(topicId, out var exchangeInfo))
+                return false;
+
+            return exchangeInfo.Symbols.Any(x => 
+                x.Value.TradingMode == symbol.TradingMode 
+                && x.Value.BaseAsset == symbol.BaseAsset 
+                && x.Value.QuoteAsset == symbol.QuoteAsset);
+        }
+
+        /// <summary>
+        /// Get all symbols for a specific base asset
+        /// </summary>
+        /// <param name="topicId">Id for the provided data</param>
+        /// <param name="baseAsset">Base asset name</param>
+        public static SharedSymbol[] GetSymbolsForBaseAsset(string topicId, string baseAsset)
+        {
+            if (!_symbolInfos.TryGetValue(topicId, out var exchangeInfo))
+                return [];
+
+            return exchangeInfo.Symbols
+                .Where(x => x.Value.BaseAsset.Equals(baseAsset, StringComparison.InvariantCultureIgnoreCase))
+                .Select(x => x.Value)
+                .ToArray();
+        }
+
        /// <summary>
        /// Parse a symbol name to a SharedSymbol
        /// </summary>
@@ -74,8 +74,13 @@ namespace CryptoExchange.Net
                {
                    if (serializationType == ArrayParametersSerialization.Array)
                    {
-                        foreach(var entry in (object[])parameter.Value)
+                        bool firstArrayValue = true;
+                        foreach (var entry in (object[])parameter.Value)
                        {
+                            if (!firstArrayValue)
+                                uriString.Append('&');
+                            firstArrayValue = false;
+
                            uriString.Append(parameter.Key);
                            uriString.Append("[]=");
                            if (urlEncodeValues)
@@ -287,122 +292,6 @@ namespace CryptoExchange.Net
            return sb.ToString();
        }

-        /// <summary>
-        /// Create a new uri with the provided parameters as query
-        /// </summary>
-        /// <param name="parameters"></param>
-        /// <param name="baseUri"></param>
-        /// <param name="arraySerialization"></param>
-        /// <returns></returns>
-        public static Uri SetParameters(this Uri baseUri, IDictionary<string, object> parameters, ArrayParametersSerialization arraySerialization)
-        {
-            var uriBuilder = new UriBuilder();
-            uriBuilder.Scheme = baseUri.Scheme;
-            uriBuilder.Host = baseUri.Host;
-            uriBuilder.Port = baseUri.Port;
-            uriBuilder.Path = baseUri.AbsolutePath;
-            var httpValueCollection = HttpUtility.ParseQueryString(string.Empty);
-            foreach (var parameter in parameters)
-            {
-                if (parameter.Value.GetType().IsArray)
-                {
-                    if (arraySerialization == ArrayParametersSerialization.JsonArray)
-                    {
-                        httpValueCollection.Add(parameter.Key, $"[{string.Join(",", (object[])parameter.Value)}]");
-                    }
-                    else
-                    {
-                        foreach (var item in (object[])parameter.Value)
-                        {
-                            if (arraySerialization == ArrayParametersSerialization.Array)
-                            {
-                                httpValueCollection.Add(parameter.Key + "[]", item.ToString());
-                            }
-                            else
-                            {
-                                httpValueCollection.Add(parameter.Key, item.ToString());
-                            }
-                        }
-                    }
-                }
-                else
-                {
-                    httpValueCollection.Add(parameter.Key, parameter.Value.ToString());
-                }
-            }
-
-            uriBuilder.Query = httpValueCollection.ToString();
-            return uriBuilder.Uri;
-        }
-
-        /// <summary>
-        /// Create a new uri with the provided parameters as query
-        /// </summary>
-        /// <param name="parameters"></param>
-        /// <param name="baseUri"></param>
-        /// <param name="arraySerialization"></param>
-        /// <returns></returns>
-        public static Uri SetParameters(this Uri baseUri, IOrderedEnumerable<KeyValuePair<string, object>> parameters, ArrayParametersSerialization arraySerialization)
-        {
-            var uriBuilder = new UriBuilder();
-            uriBuilder.Scheme = baseUri.Scheme;
-            uriBuilder.Host = baseUri.Host;
-            uriBuilder.Port = baseUri.Port;
-            uriBuilder.Path = baseUri.AbsolutePath;
-            var httpValueCollection = HttpUtility.ParseQueryString(string.Empty);
-            foreach (var parameter in parameters)
-            {
-                if (parameter.Value.GetType().IsArray)
-                {
-                    if (arraySerialization == ArrayParametersSerialization.JsonArray)
-                    {
-                        httpValueCollection.Add(parameter.Key, $"[{string.Join(",", (object[])parameter.Value)}]");
-                    }
-                    else
-                    {
-                        foreach (var item in (object[])parameter.Value)
-                        {
-                            if (arraySerialization == ArrayParametersSerialization.Array)
-                            {
-                                httpValueCollection.Add(parameter.Key + "[]", item.ToString());
-                            }
-                            else
-                            {
-                                httpValueCollection.Add(parameter.Key, item.ToString());
-                            }
-                        }
-                    }
-                }
-                else
-                {
-                    httpValueCollection.Add(parameter.Key, parameter.Value.ToString());
-                }
-            }
-
-            uriBuilder.Query = httpValueCollection.ToString();
-            return uriBuilder.Uri;
-        }
-
-        /// <summary>
-        /// Add parameter to URI
-        /// </summary>
-        /// <param name="uri"></param>
-        /// <param name="name"></param>
-        /// <param name="value"></param>
-        /// <returns></returns>
-        public static Uri AddQueryParameter(this Uri uri, string name, string value)
-        {
-            var httpValueCollection = HttpUtility.ParseQueryString(uri.Query);
-
-            httpValueCollection.Remove(name);
-            httpValueCollection.Add(name, value);
-
-            var ub = new UriBuilder(uri);
-            ub.Query = httpValueCollection.ToString();
-
-            return ub.Uri;
-        }
-
        /// <summary>
        /// Decompress using GzipStream
        /// </summary>
@@ -414,20 +303,6 @@ namespace CryptoExchange.Net
            return new ReadOnlySpan<byte>(decompressedStream.GetBuffer(), 0, (int)decompressedStream.Length);
        }

-        /// <summary>
-        /// Decompress using GzipStream
-        /// </summary>
-        public static ReadOnlyMemory<byte> DecompressGzip(this ReadOnlyMemory<byte> data)
-        {
-            using var decompressedStream = new MemoryStream();
-            using var dataStream = MemoryMarshal.TryGetArray(data, out var arraySegment)
-                ? new MemoryStream(arraySegment.Array!, arraySegment.Offset, arraySegment.Count)
-                : new MemoryStream(data.ToArray());
-            using var deflateStream = new GZipStream(dataStream, CompressionMode.Decompress);
-            deflateStream.CopyTo(decompressedStream);
-            return new ReadOnlyMemory<byte>(decompressedStream.GetBuffer(), 0, (int)decompressedStream.Length);
-        }
-
        /// <summary>
        /// Decompress using GzipStream
        /// </summary>
@@ -440,22 +315,6 @@ namespace CryptoExchange.Net
            return new ReadOnlySpan<byte>(output.GetBuffer(), 0, (int)output.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>
@@ -611,6 +470,26 @@ namespace CryptoExchange.Net

            return services;
        }
+
+        /// <summary>
+        /// Convert a hex encoded string to byte array
+        /// </summary>
+        /// <param name="hexString"></param>
+        /// <returns></returns>
+        public static byte[] HexStringToBytes(this string hexString)
+        {
+            if (hexString.StartsWith("0x"))
+                hexString = hexString.Substring(2);
+
+            byte[] bytes = new byte[hexString.Length / 2];
+            for (int i = 0; i < hexString.Length; i += 2)
+            {
+                string hexSubstring = hexString.Substring(i, 2);
+                bytes[i / 2] = Convert.ToByte(hexSubstring, 16);
+            }
+
+            return bytes;
+        }
    }
 }

@@ -22,5 +22,10 @@ namespace CryptoExchange.Net.Interfaces.Clients
        /// The exchange name
        /// </summary>
        string Exchange { get; }
+
+        /// <summary>
+        /// Whether client is disposed
+        /// </summary>
+        bool Disposed { get; }
    }
 }
@@ -35,6 +35,11 @@ namespace CryptoExchange.Net.Interfaces.Clients
        /// </summary>
        public int CurrentSubscriptions { get; }

+        /// <summary>
+        /// Whether client is disposed
+        /// </summary>
+        bool Disposed { get; }
+
        /// <summary>
        /// Unsubscribe from a stream using the subscription id received when starting the subscription
        /// </summary>
@@ -1,109 +0,0 @@
-using CryptoExchange.Net.Converters.MessageParsing;
-using CryptoExchange.Net.Objects;
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.Interfaces
-{
-    /// <summary>
-    /// Message accessor
-    /// </summary>
-    public interface IMessageAccessor
-    {
-        /// <summary>
-        /// Is this a valid message
-        /// </summary>
-        bool IsValid { get; }
-        /// <summary>
-        /// Is the original data available for retrieval
-        /// </summary>
-        bool OriginalDataAvailable { get; }
-        /// <summary>
-        /// The underlying data object
-        /// </summary>
-        object? Underlying { get; }
-        /// <summary>
-        /// Clear internal data structure
-        /// </summary>
-        void Clear();
-        /// <summary>
-        /// Get the type of node
-        /// </summary>
-        /// <returns></returns>
-        NodeType? GetNodeType();
-        /// <summary>
-        /// Get the type of node
-        /// </summary>
-        /// <param name="path">Access path</param>
-        /// <returns></returns>
-        NodeType? GetNodeType(MessagePath path);
-        /// <summary>
-        /// Get the value of a path
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="path"></param>
-        /// <returns></returns>
-        T? GetValue<T>(MessagePath path);
-        /// <summary>
-        /// Get the values of an array
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="path"></param>
-        /// <returns></returns>
-        T?[]? GetValues<T>(MessagePath path);
-        /// <summary>
-        /// Deserialize the message into this type
-        /// </summary>
-        /// <param name="type"></param>
-        /// <param name="path"></param>
-        /// <returns></returns>
-#if NET5_0_OR_GREATER
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2092:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2095:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-#endif
-        CallResult<object> Deserialize(Type type, MessagePath? path = null);
-        /// <summary>
-        /// Deserialize the message into this type
-        /// </summary>
-        /// <param name="path"></param>
-        /// <returns></returns>
-#if NET5_0_OR_GREATER
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2092:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2095:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-#endif
-        CallResult<T> Deserialize<T>(MessagePath? path = null);
-
-        /// <summary>
-        /// Get the original string value
-        /// </summary>
-        /// <returns></returns>
-        string GetOriginalString();
-    }
-
-    /// <summary>
-    /// Stream message accessor
-    /// </summary>
-    public interface IStreamMessageAccessor : IMessageAccessor
-    {
-        /// <summary>
-        /// Load a stream message
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="bufferStream"></param>
-        Task<CallResult> Read(Stream stream, bool bufferStream);
-    }
-
-    /// <summary>
-    /// Byte message accessor
-    /// </summary>
-    public interface IByteMessageAccessor : IMessageAccessor
-    {
-        /// <summary>
-        /// Load a data message
-        /// </summary>
-        /// <param name="data"></param>
-        CallResult Read(ReadOnlyMemory<byte> data);
-    }
-}
@@ -1,4 +1,5 @@
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Options;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
@@ -105,31 +106,36 @@ namespace CryptoExchange.Net
        /// <summary>
        /// Create a new HttpMessageHandler instance
        /// </summary>  
-        public static HttpMessageHandler CreateHttpClientMessageHandler(ApiProxy? proxy, TimeSpan? keepAliveInterval)
+        public static HttpMessageHandler CreateHttpClientMessageHandler(RestExchangeOptions options)
        {
 #if NET5_0_OR_GREATER
            var socketHandler = new SocketsHttpHandler();
            try
            {
-                if (keepAliveInterval != null && keepAliveInterval != TimeSpan.Zero)
+                if (options.HttpKeepAliveInterval != null && options.HttpKeepAliveInterval != TimeSpan.Zero)
                {
                    socketHandler.KeepAlivePingPolicy = HttpKeepAlivePingPolicy.Always;
-                    socketHandler.KeepAlivePingDelay = keepAliveInterval.Value;
+                    socketHandler.KeepAlivePingDelay = options.HttpKeepAliveInterval.Value;
                    socketHandler.KeepAlivePingTimeout = TimeSpan.FromSeconds(10);
                }

                socketHandler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
                socketHandler.DefaultProxyCredentials = CredentialCache.DefaultCredentials;
+
+                socketHandler.EnableMultipleHttp2Connections = options.HttpEnableMultipleHttp2Connections;
+                socketHandler.PooledConnectionLifetime = options.HttpPooledConnectionLifetime;
+                socketHandler.PooledConnectionIdleTimeout = options.HttpPooledConnectionIdleTimeout;
+                socketHandler.MaxConnectionsPerServer = options.HttpMaxConnectionsPerServer;
            }
            catch (PlatformNotSupportedException) { }
            catch (NotImplementedException) { } // Mono runtime throws NotImplementedException

-            if (proxy != null)
+            if (options.Proxy != null)
            {
                socketHandler.Proxy = new WebProxy
                {
-                    Address = new Uri($"{proxy.Host}:{proxy.Port}"),
-                    Credentials = proxy.Password == null ? null : new NetworkCredential(proxy.Login, proxy.Password)
+                    Address = new Uri($"{options.Proxy.Host}:{options.Proxy.Port}"),
+                    Credentials = options.Proxy.Password == null ? null : new NetworkCredential(options.Proxy.Login, options.Proxy.Password)
                };
            }
            return socketHandler;
@@ -143,12 +149,12 @@ namespace CryptoExchange.Net
            catch (PlatformNotSupportedException) { }
            catch (NotImplementedException) { } // Mono runtime throws NotImplementedException

-            if (proxy != null)
+            if (options.Proxy != null)
            {
                httpHandler.Proxy = new WebProxy
                {
-                    Address = new Uri($"{proxy.Host}:{proxy.Port}"),
-                    Credentials = proxy.Password == null ? null : new NetworkCredential(proxy.Login, proxy.Password)
+                    Address = new Uri($"{options.Proxy.Host}:{options.Proxy.Port}"),
+                    Credentials = options.Proxy.Password == null ? null : new NetworkCredential(options.Proxy.Login, options.Proxy.Password)
                };
            }
            return httpHandler;
@@ -37,7 +37,7 @@ namespace CryptoExchange.Net.Logging.Extensions
        private static readonly Action<ILogger, int, string, Exception?> _sendingPeriodic;
        private static readonly Action<ILogger, int, string, string, Exception?> _periodicSendFailed;
        private static readonly Action<ILogger, int, int, string, Exception?> _sendingData;
-        private static readonly Action<ILogger, int, string, string, Exception?> _receivedMessageNotMatchedToAnyListener;
+        private static readonly Action<ILogger, int, string, string, string, Exception?> _receivedMessageNotMatchedToAnyListener;
        private static readonly Action<ILogger, int, int, int, Exception?> _sendingByteData;

        static SocketConnectionLoggingExtension()
@@ -177,10 +177,10 @@ namespace CryptoExchange.Net.Logging.Extensions
                new EventId(2028, "SendingData"),
                "[Sckt {SocketId}] [Req {RequestId}] sending message: {Data}");

-            _receivedMessageNotMatchedToAnyListener = LoggerMessage.Define<int, string, string>(
+            _receivedMessageNotMatchedToAnyListener = LoggerMessage.Define<int, string, string, string>(
                LogLevel.Warning,
                new EventId(2029, "ReceivedMessageNotMatchedToAnyListener"),
-                "[Sckt {SocketId}] received message not matched to any listener. ListenId: {ListenId}, current listeners: [{ListenIds}]");
+                "[Sckt {SocketId}] received message not matched to any listener. TypeIdentifier: {TypeIdentifier}, ListenId: {ListenId}, current listeners: [{ListenIds}]");

            _failedToParse = LoggerMessage.Define<int, string>(
                LogLevel.Warning,
@@ -326,9 +326,9 @@ namespace CryptoExchange.Net.Logging.Extensions
            _sendingData(logger, socketId, requestId, data, null);
        }

-        public static void ReceivedMessageNotMatchedToAnyListener(this ILogger logger, int socketId, string listenId, string listenIds)
+        public static void ReceivedMessageNotMatchedToAnyListener(this ILogger logger, int socketId, string typeIdentifier, string listenId, string listenIds)
        {
-            _receivedMessageNotMatchedToAnyListener(logger, socketId, listenId, listenIds, null);
+            _receivedMessageNotMatchedToAnyListener(logger, socketId, typeIdentifier, listenId, listenIds, null);
        }

        public static void SendingByteData(this ILogger logger, int socketId, int requestId, int length)
@@ -1,129 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.Objects
-{
-    /// <summary>
-    /// Async auto reset based on Stephen Toub`s implementation
-    /// https://devblogs.microsoft.com/pfxteam/building-async-coordination-primitives-part-2-asyncautoresetevent/
-    /// </summary>
-    public class AsyncResetEvent : IDisposable
-    {
-        private static readonly Task<bool> _completed = Task.FromResult(true);
-        private Queue<TaskCompletionSource<bool>> _waits = new Queue<TaskCompletionSource<bool>>();
-#if NET9_0_OR_GREATER
-        private readonly Lock _waitsLock = new Lock();
-#else
-        private readonly object _waitsLock = new object();
-#endif
-        private bool _signaled;
-        private readonly bool _reset;
-
-        /// <summary>
-        /// New AsyncResetEvent
-        /// </summary>
-        /// <param name="initialState"></param>
-        /// <param name="reset"></param>
-        public AsyncResetEvent(bool initialState = false, bool reset = true)
-        {
-            _signaled = initialState;
-            _reset = reset;
-        }
-
-        /// <summary>
-        /// Wait for the AutoResetEvent to be set
-        /// </summary>
-        /// <returns></returns>
-        public async Task<bool> WaitAsync(TimeSpan? timeout = null, CancellationToken ct = default)
-        {
-            CancellationTokenRegistration registration = default;
-            try
-            {
-                Task<bool> waiter = _completed;
-                lock (_waitsLock)
-                {
-                    if (_signaled)
-                    {
-                        if (_reset)
-                            _signaled = false;
-                    }
-                    else if (!ct.IsCancellationRequested)
-                    {
-                        var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
-                        if (timeout.HasValue)
-                        {
-                            var timeoutSource = new CancellationTokenSource(timeout.Value);
-                            var cancellationSource = CancellationTokenSource.CreateLinkedTokenSource(timeoutSource.Token, ct);
-                            ct = cancellationSource.Token;
-                        }
-
-                        registration = ct.Register(() =>
-                        {
-                            lock (_waitsLock)
-                            {
-                                tcs.TrySetResult(false);
-
-                                // Not the cleanest but it works
-                                _waits = new Queue<TaskCompletionSource<bool>>(_waits.Where(i => i != tcs));
-                            }
-                        }, useSynchronizationContext: false);
-
-
-                        _waits.Enqueue(tcs);
-                        waiter = tcs.Task;
-                    }
-                }
-
-                return await waiter.ConfigureAwait(false);
-            }
-            finally
-            {
-                registration.Dispose();
-            }
-        }
-
-        /// <summary>
-        /// Signal a waiter
-        /// </summary>
-        public void Set()
-        {
-            lock (_waitsLock)
-            {
-                if (!_reset)
-                {
-                    // Act as ManualResetEvent. Once set keep it signaled and signal everyone who is waiting
-                    _signaled = true;
-                    while (_waits.Count > 0)
-                    {
-                        var toRelease = _waits.Dequeue();
-                        toRelease.TrySetResult(true);
-                    }
-                }
-                else
-                {
-                    // Act as AutoResetEvent. When set signal 1 waiter
-                    if (_waits.Count > 0)
-                    {
-                        var toRelease = _waits.Dequeue();
-                        toRelease.TrySetResult(true);
-                    }
-                    else if (!_signaled)
-                    {
-                        _signaled = true;
-                    }
-                }
-            }
-        }
-
-        /// <summary>
-        /// Dispose
-        /// </summary>
-        public void Dispose()
-        {
-            _waits.Clear();
-        }
-    }
-}
@@ -0,0 +1,149 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Objects
+{
+    /// <summary>
+    /// Async auto/manual reset event implementation
+    /// </summary>
+    public class AsyncResetEvent
+    {
+        private readonly Queue<TaskCompletionSource<bool>> _waiters = new();
+        private readonly bool _autoReset;
+        private bool _signaled;
+#if NET9_0_OR_GREATER
+        private readonly Lock _waitersLock = new Lock();
+#else
+        private readonly object _waitersLock = new object();
+#endif
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public AsyncResetEvent(bool initialState = false, bool autoReset = true)
+        {
+            _signaled = initialState;
+            _autoReset = autoReset;
+        }
+
+        /// <summary>
+        /// Wait for the set event
+        /// </summary>
+        /// <returns></returns>
+        public async Task<bool> WaitAsync(
+            TimeSpan? timeout = null,
+            CancellationToken ct = default)
+        {
+            TaskCompletionSource<bool> tcs;
+
+            lock (_waitersLock)
+            {
+                if (_signaled)
+                {
+                    // Already was signaled, can return immediately
+                    if (_autoReset)
+                        _signaled = false;
+
+                    return true;
+                }
+
+                tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+                _waiters.Enqueue(tcs);
+            }
+
+            CancellationTokenSource? delayCts = null;
+
+            try
+            {
+                if (timeout.HasValue || ct.CanBeCanceled)
+                {
+                    delayCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+
+                    var delayTask = Task.Delay(
+                        timeout ?? Timeout.InfiniteTimeSpan,
+                        delayCts.Token);
+
+                    var completedTask =
+                        await Task.WhenAny(tcs.Task, delayTask)
+                                  .ConfigureAwait(false);
+
+                    if (completedTask != tcs.Task)
+                    {
+                        // This was a timeout or cancellation, need to remove tcs from waiters
+                        // if the tcs was set instead it will be removed in the Set method
+                        if (tcs.TrySetResult(false))
+                        {
+                            lock (_waitersLock)
+                            {
+                                // Dequeue and put in the back of the queue again except for the one we need to remove
+                                int count = _waiters.Count;
+                                for (int i = 0; i < count; i++)
+                                {
+                                    var w = _waiters.Dequeue();
+                                    if (w != tcs)
+                                        _waiters.Enqueue(w);
+                                }
+                            }
+                        }
+
+                        return false;
+                    }
+                }
+                else
+                {
+                    await tcs.Task.ConfigureAwait(false);
+                }
+
+                return true;
+            }
+            finally
+            {
+                // Actively stop the delay if tcs.Task won
+                delayCts?.Cancel();
+                delayCts?.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Signal a waiter
+        /// </summary>
+        public void Set()
+        {
+            if (!_autoReset && _signaled)
+                // Already signaled and not resetting
+                return;
+
+            lock (_waitersLock)
+            {
+                if (_autoReset)
+                {
+                    while (_waiters.Count > 0)
+                    {
+                        // Try to dequeue and set the result
+                        // If result setting was not successful it means timeout/cancellation happened at the same time
+                        // If this is the case this Set isn't the one setting the result and we need to continue
+                        var w = _waiters.Dequeue();
+                        if (w.TrySetResult(true))
+                            return;
+                    }
+
+                    // No queued waiters, set signaled for next waiter
+                    _signaled = true;
+                }
+                else
+                {
+                    _signaled = true;
+
+                    // Signal all current waiters
+                    while (_waiters.Count > 0)
+                    {
+                        var w = _waiters.Dequeue();
+                        w.TrySetResult(true);
+                    }
+                }
+            }
+        }
+    }
+}
@@ -531,11 +531,11 @@ namespace CryptoExchange.Net.Objects
        /// <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>
+        /// <param name="nextPageRequest">Next page request</param>
        /// <returns></returns>
-        public ExchangeWebResult<K> AsExchangeResult<K>(string exchange, TradingMode tradeMode, [AllowNull] K data, INextPageToken? nextPageToken = null)
+        public ExchangeWebResult<K> AsExchangeResult<K>(string exchange, TradingMode tradeMode, [AllowNull] K data, PageRequest? nextPageRequest = null)
        {
-            return new ExchangeWebResult<K>(exchange, tradeMode, As<K>(data), nextPageToken);
+            return new ExchangeWebResult<K>(exchange, tradeMode, As<K>(data), nextPageRequest);
        }

        /// <summary>
@@ -545,11 +545,11 @@ namespace CryptoExchange.Net.Objects
        /// <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>
+        /// <param name="nextPageRequest">Next page token</param>
        /// <returns></returns>
-        public ExchangeWebResult<K> AsExchangeResult<K>(string exchange, TradingMode[]? tradeModes, [AllowNull] K data, INextPageToken? nextPageToken = null)
+        public ExchangeWebResult<K> AsExchangeResult<K>(string exchange, TradingMode[]? tradeModes, [AllowNull] K data, PageRequest? nextPageRequest = null)
        {
-            return new ExchangeWebResult<K>(exchange, tradeModes, As<K>(data), nextPageToken);
+            return new ExchangeWebResult<K>(exchange, tradeModes, As<K>(data), nextPageRequest);
        }

        /// <summary>
@@ -250,6 +250,40 @@
        DEX
    }

+    /// <summary>
+    /// Type of platform
+    /// </summary>
+    public enum PlatformType 
+    { 
+        /// <summary>
+        /// Platform to trade cryptocurrency
+        /// </summary>
+        CryptoCurrencyExchange,
+        /// <summary>
+        /// Platform for trading on predictions
+        /// </summary>
+        PredictionMarket,
+        /// <summary>
+        /// Other
+        /// </summary>
+        Other
+    }
+
+    /// <summary>
+    /// Centralization type
+    /// </summary>
+    public enum CentralizationType
+    {
+        /// <summary>
+        /// Centralized, a person or company is in full control
+        /// </summary>
+        Centralized,
+        /// <summary>
+        /// Decentralized, governance is split over different entities with no single entity in full control
+        /// </summary>
+        Decentralized
+    }
+
    /// <summary>
    /// Timeout behavior for queries
    /// </summary>
@@ -211,7 +211,15 @@ namespace CryptoExchange.Net.Objects
        /// <summary>
        /// ctor
        /// </summary>
-        public DeserializeError(string? message = null, Exception? exception = null) : base(null, _errorInfo with { Message = (message?.Length > 0 ? _errorInfo.Message + ": " + message : _errorInfo.Message) }, exception) { }
+        public DeserializeError(string? message = null, Exception? exception = null) 
+            : base(null, 
+                  _errorInfo with 
+                  {
+                      Message = message?.Length > 0 
+                        ? message
+                        : _errorInfo.Message
+                  },
+                  exception) { }
    }

    /// <summary>
@@ -7,6 +7,11 @@ namespace CryptoExchange.Net.Objects.Options
    /// </summary>
    public class ApiOptions
    {
+        /// <summary>
+        /// Whether or not to automatically sync the local time with the server time
+        /// </summary>
+        public bool? AutoTimestamp { get; set; }
+
        /// <summary>
        /// If true, the CallResult and DataEvent objects will also include the originally received string data in the OriginalData property.
        /// Note that this comes at a performance cost
@@ -8,6 +8,10 @@ namespace CryptoExchange.Net.Objects.Options
    /// </summary>
    public class ExchangeOptions
    {
+        /// <summary>
+        /// Whether or not to automatically sync the local time with the server time
+        /// </summary>
+        public bool AutoTimestamp { get; set; }
        /// <summary>
        /// Proxy settings
        /// </summary>
@@ -8,11 +8,6 @@ namespace CryptoExchange.Net.Objects.Options
    /// </summary>
    public class RestApiOptions : ApiOptions
    {
-        /// <summary>
-        /// Whether or not to automatically sync the local time with the server time
-        /// </summary>
-        public bool? AutoTimestamp { get; set; }
-
        /// <summary>
        /// How often the timestamp adjustment between client and server is recalculated. If you need a very small TimeSpan here you're probably better of syncing your server time more often
        /// </summary>
@@ -8,11 +8,6 @@ namespace CryptoExchange.Net.Objects.Options
    /// </summary>
    public class RestExchangeOptions: ExchangeOptions
    {
-        /// <summary>
-        /// Whether or not to automatically sync the local time with the server time
-        /// </summary>
-        public bool AutoTimestamp { get; set; }
-
        /// <summary>
        /// How often the timestamp adjustment between client and server is recalculated. If you need a very small TimeSpan here you're probably better of syncing your server time more often
        /// </summary>
@@ -37,10 +32,29 @@ namespace CryptoExchange.Net.Objects.Options
 #else
            = new Version(1, 1);
 #endif
+
        /// <summary>
-        /// Http client keep alive interval for keeping connections open
+        /// Http client keep alive interval for keeping connections open. Only applied when using dotnet8.0 or higher and dependency injection
        /// </summary>
        public TimeSpan? HttpKeepAliveInterval { get; set; } = TimeSpan.FromSeconds(15);
+#if NET5_0_OR_GREATER
+        /// <summary>
+        /// Enable multiple simultaneous HTTP 2 connections. Only applied when using dependency injection
+        /// </summary>
+        public bool HttpEnableMultipleHttp2Connections { get; set; } = false;
+        /// <summary>
+        /// Lifetime of pooled HTTP connections; the time before a connection is recreated. Only applied when using dependency injection
+        /// </summary>
+        public TimeSpan HttpPooledConnectionLifetime { get; set; } = TimeSpan.FromMinutes(15);
+        /// <summary>
+        /// Idle timeout of pooled HTTP connections; the time before an open connection is closed when there are no requests. Only applied when using dependency injection
+        /// </summary>
+        public TimeSpan HttpPooledConnectionIdleTimeout { get; set; } = TimeSpan.FromMinutes(2);
+        /// <summary>
+        /// Max number of connections per server. Only applied when using dependency injection
+        /// </summary>
+        public int HttpMaxConnectionsPerServer { get; set; } = int.MaxValue;
+#endif 

        /// <summary>
        /// Set the values of this options on the target options
@@ -59,6 +73,12 @@ namespace CryptoExchange.Net.Objects.Options
            item.CachingMaxAge = CachingMaxAge;
            item.HttpVersion = HttpVersion;
            item.HttpKeepAliveInterval = HttpKeepAliveInterval;
+#if NET5_0_OR_GREATER
+            item.HttpMaxConnectionsPerServer = HttpMaxConnectionsPerServer;
+            item.HttpPooledConnectionLifetime = HttpPooledConnectionLifetime;
+            item.HttpPooledConnectionIdleTimeout = HttpPooledConnectionIdleTimeout;
+            item.HttpEnableMultipleHttp2Connections = HttpEnableMultipleHttp2Connections;
+#endif
            return item;
        }
    }
@@ -27,6 +27,7 @@ namespace CryptoExchange.Net.Objects.Options
            item.ApiCredentials = ApiCredentials?.Copy();
            item.OutputOriginalData = OutputOriginalData;
            item.SocketNoDataTimeout = SocketNoDataTimeout;
+            item.AutoTimestamp = AutoTimestamp;
            item.MaxSocketConnections = MaxSocketConnections;
            return item;
        }
@@ -76,9 +76,13 @@ namespace CryptoExchange.Net.Objects.Options
        public int? ReceiveBufferSize { get; set; }

        /// <summary>
-        /// Whether or not to use the updated deserialization logic, default is true
+        /// ctor
        /// </summary>
-        public bool UseUpdatedDeserialization { get; set; } = true;
+        public SocketExchangeOptions()
+        {
+            // Enable auto timestamping by default for sockets
+            AutoTimestamp = true;
+        }

        /// <summary>
        /// Create a copy of this options
@@ -88,6 +92,7 @@ namespace CryptoExchange.Net.Objects.Options
        public T Set<T>(T item) where T : SocketExchangeOptions, new()
        {
            item.ApiCredentials = ApiCredentials?.Copy();
+            item.AutoTimestamp = AutoTimestamp;
            item.OutputOriginalData = OutputOriginalData;
            item.ReconnectPolicy = ReconnectPolicy;
            item.DelayAfterConnect = DelayAfterConnect;
@@ -101,7 +106,6 @@ namespace CryptoExchange.Net.Objects.Options
            item.RateLimitingBehaviour = RateLimitingBehaviour;
            item.RateLimiterEnabled = RateLimiterEnabled;
            item.ReceiveBufferSize = ReceiveBufferSize;
-            item.UseUpdatedDeserialization = UseUpdatedDeserialization;
            return item;
        }
    }
@@ -96,6 +96,23 @@ namespace CryptoExchange.Net.Objects
                base.Add(key, value.Value.ToString(CultureInfo.InvariantCulture));
        }

+        /// <summary>
+        /// Add a DateTime value as string
+        /// </summary>
+        public void AddString(string key, DateTime value)
+        {
+            base.Add(key, value.ToString("yyyy-MM-ddTHH:mm:ssZ"));
+        }
+
+        /// <summary>
+        /// Add a DateTime value as string. Not added if value is null
+        /// </summary>
+        public void AddOptionalString(string key, DateTime? value)
+        {
+            if (value != null)
+                base.Add(key, value.Value.ToString("yyyy-MM-ddTHH:mm:ssZ"));
+        }
+
        /// <summary>
        /// Add a datetime value as milliseconds timestamp
        /// </summary>
@@ -241,6 +258,45 @@ namespace CryptoExchange.Net.Objects
                base.Add(key, int.Parse(stringVal));
            }
        }
+        
+        /// <summary>
+        /// Add key as comma separated values
+        /// </summary>
+        public void AddCommaSeparated(string key, IEnumerable<string> values)
+        {
+            base.Add(key, string.Join(",", values));
+        }
+
+        /// <summary>
+        /// Add key as comma separated values if there are values provided
+        /// </summary>
+        public void AddOptionalCommaSeparated(string key, IEnumerable<string>? values)
+        {
+            if (values == null || !values.Any())
+                return;
+
+            base.Add(key, string.Join(",", values));
+        }
+
+        /// <summary>
+        /// Add key as boolean lower case value
+        /// </summary>
+        public void AddBoolString(string key, bool value)
+        {
+            base.Add(key, value.ToString().ToLower());
+        }
+
+        /// <summary>
+        /// Add key as boolean lower case value if it's not null
+        /// </summary>
+        public void AddOptionalBoolString(string key, bool? value)
+        {
+            if (value == null)
+                return;
+
+            base.Add(key, value.ToString()!.ToLower());
+        }
+

        /// <summary>
        /// Set the request body. Can be used to specify a simple value or array as the body instead of an object
@@ -0,0 +1,51 @@
+namespace CryptoExchange.Net.Objects
+{
+    /// <summary>
+    /// Information on the platform
+    /// </summary>
+    public record PlatformInfo
+    {
+        /// <summary>
+        /// Platform id
+        /// </summary>
+        public string Id { get; }
+        /// <summary>
+        /// Display name
+        /// </summary>
+        public string DisplayName { get; }
+        /// <summary>
+        /// Logo
+        /// </summary>
+        public string Logo { get; }
+        /// <summary>
+        /// Url to main application
+        /// </summary>
+        public string Url { get; }
+        /// <summary>
+        /// Urls to the API documentation
+        /// </summary>
+        public string[] ApiDocsUrl { get; }
+        /// <summary>
+        /// Platform type
+        /// </summary>
+        public PlatformType PlatformType { get; }
+        /// <summary>
+        /// Centralization type
+        /// </summary>
+        public CentralizationType CentralizationType { get; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public PlatformInfo(string id, string displayName, string logo, string url, string[] apiDocsUrl, PlatformType platformType, CentralizationType centralizationType)
+        {
+            Id = id;
+            DisplayName = displayName;
+            Logo = logo;
+            Url = url;
+            ApiDocsUrl = apiDocsUrl;
+            PlatformType = platformType;
+            CentralizationType = centralizationType;
+        }
+    }
+}
@@ -170,6 +170,6 @@ namespace CryptoExchange.Net.Objects.Sockets
        }

        /// <inheritdoc />
-        public override string ToString() => base.ToString().TrimEnd('-') + Data?.ToString();
+        public override string ToString() => base.ToString().TrimEnd(' ', '-') + " - " + Data?.ToString();
    }
 }
@@ -109,6 +109,21 @@ namespace CryptoExchange.Net.Objects.Sockets
        /// </summary>
        public int Id => _subscription.Id;

+        /// <summary>
+        /// The last timestamp anything was received from the server
+        /// </summary>
+        public DateTime? LastReceiveTime => _connection.LastReceiveTime;
+
+        /// <summary>
+        /// The current websocket status
+        /// </summary>
+        public SocketStatus SocketStatus => _connection.Status;
+
+        /// <summary>
+        /// The current subscription status
+        /// </summary>
+        public SubscriptionStatus SubscriptionStatus => _subscription.Status;
+
        /// <summary>
        /// ctor
        /// </summary>
@@ -73,11 +73,6 @@ namespace CryptoExchange.Net.Objects.Sockets
        /// The buffer size to use for receiving data
        /// </summary>
        public int? ReceiveBufferSize { get; set; } = null;
-        
-        /// <summary>
-        /// Whether or not to use the updated deserialization logic
-        /// </summary>
-        public bool UseUpdatedDeserialization { get; set; }

        /// <summary>
        /// ctor
@@ -332,7 +332,6 @@ namespace CryptoExchange.Net.OrderBook
        public async Task StopAsync()
        {
            _logger.OrderBookStopping(Api, Symbol);
-            Status = OrderBookStatus.Disconnected;
            _cts?.Cancel();
            _queueEvent.Set();
            if (_processTask != null)
@@ -345,6 +344,7 @@ namespace CryptoExchange.Net.OrderBook
                _subscription.ConnectionRestored -= HandleConnectionRestored;
            }

+            Status = OrderBookStatus.Disconnected;
            _logger.OrderBookStopped(Api, Symbol);
        }

@@ -448,6 +448,9 @@ namespace CryptoExchange.Net.OrderBook
            DateTime? serverDataTime = null,
            DateTime? localDataTime = null)
        {
+            if (Status == OrderBookStatus.Disposed || Status == OrderBookStatus.Disconnected)
+                throw new InvalidOperationException("Trying to set snapshot while book is not working");
+
            _processQueue.Enqueue(
                new OrderBookSnapshot
                {
@@ -475,6 +478,9 @@ namespace CryptoExchange.Net.OrderBook
            DateTime? serverDataTime = null,
            DateTime? localDataTime = null)
        {
+            if (Status == OrderBookStatus.Disposed || Status == OrderBookStatus.Disconnected)
+                throw new InvalidOperationException("Trying to update order book while book is not working");
+
            _processQueue.Enqueue(
                new OrderBookUpdate
                { 
@@ -505,6 +511,9 @@ namespace CryptoExchange.Net.OrderBook
            DateTime? serverDataTime = null,
            DateTime? localDataTime = null)
        {
+            if (Status == OrderBookStatus.Disposed || Status == OrderBookStatus.Disconnected)
+                throw new InvalidOperationException("Trying to update order book while book is not working");
+
            _processQueue.Enqueue(
                new OrderBookUpdate
                {
@@ -531,6 +540,9 @@ namespace CryptoExchange.Net.OrderBook
            DateTime? serverDataTime = null,
            DateTime? localDataTime = null)
        {
+            if (Status == OrderBookStatus.Disposed || Status == OrderBookStatus.Disconnected)
+                throw new InvalidOperationException("Trying to update order book while book is not working");
+
            var highest = Math.Max(bids.Any() ? bids.Max(b => b.Sequence) : 0, asks.Any() ? asks.Max(a => a.Sequence) : 0);
            var lowest = Math.Min(bids.Any() ? bids.Min(b => b.Sequence) : long.MaxValue, asks.Any() ? asks.Min(a => a.Sequence) : long.MaxValue);

@@ -554,6 +566,9 @@ namespace CryptoExchange.Net.OrderBook
        /// <param name="sequenceNumber">The sequence number of the message if it's a separate message with separate number</param>
        protected void AddChecksum(int checksum, long? sequenceNumber = null)
        {
+            if (Status == OrderBookStatus.Disposed || Status == OrderBookStatus.Disconnected)
+                throw new InvalidOperationException("Trying to add checksum while book is not working");
+
            _processQueue.Enqueue(new OrderBookChecksum() { Checksum = checksum, SequenceNumber = sequenceNumber });
            _queueEvent.Set();
        }
@@ -640,6 +655,42 @@ namespace CryptoExchange.Net.OrderBook
            return new CallResult<bool>(true);
        }

+        /// <summary>
+        /// Wait until an update has been buffered
+        /// </summary>
+        /// <param name="minWait">Min wait time</param>
+        /// <param name="maxWait">Max wait time</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <returns></returns>
+        protected async Task<CallResult> WaitUntilFirstUpdateBufferedAsync(TimeSpan? minWait, TimeSpan maxWait, CancellationToken ct)
+        {
+            var startWait = DateTime.UtcNow;
+            while (_processBuffer.Count == 0)
+            {
+                if (ct.IsCancellationRequested)
+                    return new CallResult(new CancellationRequestedError());
+
+                if (DateTime.UtcNow - startWait > maxWait)
+                    return new CallResult(new ServerError(new ErrorInfo(ErrorType.OrderBookTimeout, "Timeout while waiting for data")));
+
+                try
+                {
+                    await Task.Delay(20, ct).ConfigureAwait(false);
+                }
+                catch (OperationCanceledException)
+                { }
+            }
+
+            if (minWait != null)
+            {
+                var dif = DateTime.UtcNow - startWait;
+                if (dif < minWait)
+                    await Task.Delay(minWait.Value - dif).ConfigureAwait(false);
+            }
+
+            return CallResult.SuccessResult;
+        }
+
        /// <summary>
        /// IDisposable implementation for the order book
        /// </summary>
@@ -1002,7 +1053,8 @@ namespace CryptoExchange.Net.OrderBook

        private SequenceNumberResult ValidateLiveSequenceNumber(long sequenceNumber)
        {
-            if (sequenceNumber < LastSequenceNumber)
+            if (sequenceNumber < LastSequenceNumber 
+                && (_firstUpdateAfterSnapshotDone || !_skipSequenceCheckFirstUpdateAfterSnapshotSet))
                // Update is somehow from before the current state
                return SequenceNumberResult.OutOfSync;

@@ -17,11 +17,11 @@ namespace CryptoExchange.Net.RateLimiting.Filters
        /// <param name="path"></param>
        public PathStartFilter(string path)
        {
-            _path = path;
+            _path = path.TrimStart('/');
        }

        /// <inheritdoc />
        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey)
-            => definition.Path.StartsWith(_path, StringComparison.OrdinalIgnoreCase);
+            => definition.Path.TrimStart('/').StartsWith(_path, StringComparison.OrdinalIgnoreCase);
    }
 }
@@ -12,14 +12,16 @@ namespace CryptoExchange.Net.Requests
    public class RequestFactory : IRequestFactory
    {
        private HttpClient? _httpClient;
+        private RestExchangeOptions? _options;

        /// <inheritdoc />
        public void Configure(RestExchangeOptions options, HttpClient? client = null)
        {
            if (client == null)
-                client = CreateClient(options.Proxy, options.RequestTimeout, options.HttpKeepAliveInterval);
+                client = CreateClient(options);

            _httpClient = client;
+            _options = options;
        }

        /// <inheritdoc />
@@ -39,15 +41,20 @@ namespace CryptoExchange.Net.Requests
        /// <inheritdoc />
        public void UpdateSettings(ApiProxy? proxy, TimeSpan requestTimeout, TimeSpan? httpKeepAliveInterval)
        {
-            _httpClient = CreateClient(proxy, requestTimeout, httpKeepAliveInterval);
+            var newOptions = new RestExchangeOptions();
+            _options!.Set(newOptions);
+            newOptions.Proxy = proxy;
+            newOptions.RequestTimeout = requestTimeout;
+            newOptions.HttpKeepAliveInterval = httpKeepAliveInterval;
+            _httpClient = CreateClient(newOptions);
        }

-        private static HttpClient CreateClient(ApiProxy? proxy, TimeSpan requestTimeout, TimeSpan? httpKeepAliveInterval)
+        private static HttpClient CreateClient(RestExchangeOptions options)
        {
-            var handler = LibraryHelpers.CreateHttpClientMessageHandler(proxy, httpKeepAliveInterval);
+            var handler = LibraryHelpers.CreateHttpClientMessageHandler(options);
            var client = new HttpClient(handler)
            {
-                Timeout = requestTimeout                
+                Timeout = options.RequestTimeout
            };
            return client;
        }
@@ -0,0 +1,21 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Transfer status
+    /// </summary>
+    public enum SharedTransferStatus
+    {
+        /// <summary>
+        /// In progress
+        /// </summary>
+        InProgress,
+        /// <summary>
+        /// Failed
+        /// </summary>
+        Failed,
+        /// <summary>
+        /// Completed
+        /// </summary>
+        Completed
+    }
+}
@@ -1,111 +0,0 @@
-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;
-        }
-    }
-}
@@ -16,8 +16,8 @@ namespace CryptoExchange.Net.SharedApis
        /// 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="nextPageToken">The pagination request from the previous request result `NextPageRequest` property to continue pagination</param>
        /// <param name="ct">Cancellation token</param>
-        Task<ExchangeWebResult<SharedFundingRate[]>> GetFundingRateHistoryAsync(GetFundingRateHistoryRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+        Task<ExchangeWebResult<SharedFundingRate[]>> GetFundingRateHistoryAsync(GetFundingRateHistoryRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
    }
 }
@@ -73,14 +73,14 @@ namespace CryptoExchange.Net.SharedApis
        /// <summary>
        /// Spot get closed orders request options
        /// </summary>
-        PaginatedEndpointOptions<GetClosedOrdersRequest> GetClosedFuturesOrdersOptions { get; }
+        GetClosedOrdersOptions 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="nextPageToken">The pagination request from the previous request result `NextPageRequest` property to continue pagination</param>
        /// <param name="ct">Cancellation token</param>
-        Task<ExchangeWebResult<SharedFuturesOrder[]>> GetClosedFuturesOrdersAsync(GetClosedOrdersRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+        Task<ExchangeWebResult<SharedFuturesOrder[]>> GetClosedFuturesOrdersAsync(GetClosedOrdersRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);

        /// <summary>
        /// Futures get order trades request options
@@ -96,14 +96,14 @@ namespace CryptoExchange.Net.SharedApis
        /// <summary>
        /// Futures user trades request options
        /// </summary>
-        PaginatedEndpointOptions<GetUserTradesRequest> GetFuturesUserTradesOptions { get; }
+        GetUserTradesOptions 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="nextPageToken">The pagination request from the previous request result `NextPageRequest` property to continue pagination</param>
        /// <param name="ct">Cancellation token</param>
-        Task<ExchangeWebResult<SharedUserTrade[]>> GetFuturesUserTradesAsync(GetUserTradesRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+        Task<ExchangeWebResult<SharedUserTrade[]>> GetFuturesUserTradesAsync(GetUserTradesRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);

        /// <summary>
        /// Futures cancel order request options
@@ -12,6 +12,25 @@ namespace CryptoExchange.Net.SharedApis
        /// Futures symbol request options
        /// </summary>
        EndpointOptions<GetSymbolsRequest> GetFuturesSymbolsOptions { get; }
+
+        /// <summary>
+        /// Get all futures symbols for a specific base asset
+        /// </summary>
+        /// <param name="baseAsset">Asset, for example `ETH`</param>
+        Task<ExchangeResult<SharedSymbol[]>> GetFuturesSymbolsForBaseAssetAsync(string baseAsset);
+
+        /// <summary>
+        /// Gets whether the client supports a futures symbol
+        /// </summary>
+        /// <param name="symbol">The symbol</param>
+        Task<ExchangeResult<bool>> SupportsFuturesSymbolAsync(SharedSymbol symbol);
+
+        /// <summary>
+        /// Gets whether the client supports a futures symbol
+        /// </summary>
+        /// <param name="symbolName">The symbol name</param>
+        Task<ExchangeResult<bool>> SupportsFuturesSymbolAsync(string symbolName);
+
        /// <summary>
        /// Get info on all futures symbols supported on the exchange
        /// </summary>
@@ -16,8 +16,8 @@ namespace CryptoExchange.Net.SharedApis
        /// 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="nextPageToken">The pagination request from the previous request result `NextPageRequest` property to continue pagination</param>
        /// <param name="ct">Cancellation token</param>
-        Task<ExchangeWebResult<SharedFuturesKline[]>> GetIndexPriceKlinesAsync(GetKlinesRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+        Task<ExchangeWebResult<SharedFuturesKline[]>> GetIndexPriceKlinesAsync(GetKlinesRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
    }
 }
@@ -16,8 +16,8 @@ namespace CryptoExchange.Net.SharedApis
        /// Get mark 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="nextPageToken">The pagination request from the previous request result `NextPageRequest` property to continue pagination</param>
        /// <param name="ct">Cancellation token</param>
-        Task<ExchangeWebResult<SharedFuturesKline[]>> GetMarkPriceKlinesAsync(GetKlinesRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+        Task<ExchangeWebResult<SharedFuturesKline[]>> GetMarkPriceKlinesAsync(GetKlinesRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
    }
 }
@@ -16,8 +16,8 @@ namespace CryptoExchange.Net.SharedApis
        /// Get position history
        /// </summary>
        /// <param name="request">Request info</param>
-        /// <param name="nextPageToken">The pagination token from the previous request to continue pagination</param>
+        /// <param name="nextPageToken">The pagination request from the previous request result `NextPageRequest` property to continue pagination</param>
        /// <param name="ct">Cancellation token</param>
-        Task<ExchangeWebResult<SharedPositionHistory[]>> GetPositionHistoryAsync(GetPositionHistoryRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+        Task<ExchangeWebResult<SharedPositionHistory[]>> GetPositionHistoryAsync(GetPositionHistoryRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
    }
 }
@@ -30,9 +30,9 @@ namespace CryptoExchange.Net.SharedApis
        /// Get deposit records
        /// </summary>
        /// <param name="request">Request info</param>
-        /// <param name="nextPageToken">The pagination token from the previous request to continue pagination</param>
+        /// <param name="nextPageToken">The pagination request from the previous request result `NextPageRequest` property to continue pagination</param>
        /// <param name="ct">Cancellation token</param>
        /// <returns></returns>
-        Task<ExchangeWebResult<SharedDeposit[]>> GetDepositsAsync(GetDepositsRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+        Task<ExchangeWebResult<SharedDeposit[]>> GetDepositsAsync(GetDepositsRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
    }
 }
@@ -17,9 +17,9 @@ namespace CryptoExchange.Net.SharedApis
        /// Get 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="nextPageToken">The pagination request from the previous request result `NextPageRequest` property to continue pagination</param>
        /// <param name="ct">Cancellation token</param>
        /// <returns></returns>
-        Task<ExchangeWebResult<SharedKline[]>> GetKlinesAsync(GetKlinesRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+        Task<ExchangeWebResult<SharedKline[]>> GetKlinesAsync(GetKlinesRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
    }
 }
@@ -17,9 +17,9 @@ namespace CryptoExchange.Net.SharedApis
        /// Get public trade history
        /// </summary>
        /// <param name="request">Request info</param>
-        /// <param name="nextPageToken">The pagination token from the previous request to continue pagination</param>
+        /// <param name="nextPageToken">The pagination request from the previous request result `NextPageRequest` property to continue pagination</param>
        /// <param name="ct">Cancellation token</param>
        /// <returns></returns>
-        Task<ExchangeWebResult<SharedTrade[]>> GetTradeHistoryAsync(GetTradeHistoryRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+        Task<ExchangeWebResult<SharedTrade[]>> GetTradeHistoryAsync(GetTradeHistoryRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
    }
 }
@@ -17,9 +17,9 @@ namespace CryptoExchange.Net.SharedApis
        /// Get withdrawal records
        /// </summary>
        /// <param name="request">Request info</param>
-        /// <param name="nextPageToken">The pagination token from the previous request to continue pagination</param>
+        /// <param name="nextPageToken">The pagination request from the previous request result `NextPageRequest` property to continue pagination</param>
        /// <param name="ct">Cancellation token</param>
        /// <returns></returns>
-        Task<ExchangeWebResult<SharedWithdrawal[]>> GetWithdrawalsAsync(GetWithdrawalsRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+        Task<ExchangeWebResult<SharedWithdrawal[]>> GetWithdrawalsAsync(GetWithdrawalsRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
    }
 }
@@ -72,14 +72,14 @@ namespace CryptoExchange.Net.SharedApis
        /// <summary>
        /// Spot get closed orders request options
        /// </summary>
-        PaginatedEndpointOptions<GetClosedOrdersRequest> GetClosedSpotOrdersOptions { get; }
+        GetClosedOrdersOptions GetClosedSpotOrdersOptions { get; }
        /// <summary>
        /// Get info on closed spot orders
        /// </summary>
        /// <param name="request">Request info</param>
-        /// <param name="nextPageToken">The pagination token from the previous request to continue pagination</param>
+        /// <param name="nextPageToken">The pagination request from the previous request result `NextPageRequest` property to continue pagination</param>
        /// <param name="ct">Cancellation token</param>
-        Task<ExchangeWebResult<SharedSpotOrder[]>> GetClosedSpotOrdersAsync(GetClosedOrdersRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+        Task<ExchangeWebResult<SharedSpotOrder[]>> GetClosedSpotOrdersAsync(GetClosedOrdersRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);

        /// <summary>
        /// Spot get order trades request options
@@ -95,14 +95,14 @@ namespace CryptoExchange.Net.SharedApis
        /// <summary>
        /// Spot user trades request options
        /// </summary>
-        PaginatedEndpointOptions<GetUserTradesRequest> GetSpotUserTradesOptions { get; }
+        GetUserTradesOptions GetSpotUserTradesOptions { get; }
        /// <summary>
        /// Get spot 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="nextPageToken">The pagination request from the previous request result `NextPageRequest` property to continue pagination</param>
        /// <param name="ct">Cancellation token</param>
-        Task<ExchangeWebResult<SharedUserTrade[]>> GetSpotUserTradesAsync(GetUserTradesRequest request, INextPageToken? nextPageToken = null, CancellationToken ct = default);
+        Task<ExchangeWebResult<SharedUserTrade[]>> GetSpotUserTradesAsync(GetUserTradesRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);

        /// <summary>
        /// Spot cancel order request options
@@ -1,4 +1,5 @@
-using System.Threading;
+using CryptoExchange.Net.Objects;
+using System.Threading;
 using System.Threading.Tasks;

 namespace CryptoExchange.Net.SharedApis
@@ -13,6 +14,24 @@ namespace CryptoExchange.Net.SharedApis
        /// </summary>
        EndpointOptions<GetSymbolsRequest> GetSpotSymbolsOptions { get; }

+        /// <summary>
+        /// Get all spot symbols for a specific base asset
+        /// </summary>
+        /// <param name="baseAsset">Asset, for example `ETH`</param>
+        Task<ExchangeResult<SharedSymbol[]>> GetSpotSymbolsForBaseAssetAsync(string baseAsset);
+
+        /// <summary>
+        /// Gets whether the client supports a spot symbol
+        /// </summary>
+        /// <param name="symbol">The symbol</param>
+        Task<ExchangeResult<bool>> SupportsSpotSymbolAsync(SharedSymbol symbol);
+
+        /// <summary>
+        /// Gets whether the client supports a spot symbol
+        /// </summary>
+        /// <param name="symbolName">The symbol name</param>
+        Task<ExchangeResult<bool>> SupportsSpotSymbolAsync(string symbolName);
+
        /// <summary>
        /// Get info on all available spot symbols on the exchange
        /// </summary>
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Data.Common;
 using System.Linq;

 namespace CryptoExchange.Net.SharedApis
@@ -99,6 +100,9 @@ namespace CryptoExchange.Net.SharedApis
            if (val == null)
                return default;

+            if (val.Value is T typeVal)
+                return typeVal;
+
            try
            {
                Type t = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
@@ -38,6 +38,17 @@ namespace CryptoExchange.Net.SharedApis
            Exchange = exchange;
        }

+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ExchangeResult(
+            string exchange,
+            T result) :
+            base(result, null, null)
+        {
+            Exchange = exchange;
+        }
+
        /// <inheritdoc />
        public override string ToString() => $"{Exchange} - " + base.ToString();
    }
@@ -24,9 +24,9 @@ namespace CryptoExchange.Net.SharedApis
        public TradingMode[]? DataTradeMode { get; }

        /// <summary>
-        /// Token to retrieve the next page with
+        /// Next page request, can be passed to the next request on the same endpoint to get the next page
        /// </summary>
-        public INextPageToken? NextPageToken { get; }
+        public PageRequest? NextPageRequest { get; }

        /// <summary>
        /// ctor
@@ -46,7 +46,7 @@ namespace CryptoExchange.Net.SharedApis
            string exchange,
            TradingMode dataTradeMode,
            WebCallResult<T> result,
-            INextPageToken? nextPageToken = null) :
+            PageRequest? nextPageToken = null) :
            base(result.ResponseStatusCode,
                result.HttpVersion,
                result.ResponseHeaders,
@@ -64,7 +64,7 @@ namespace CryptoExchange.Net.SharedApis
        {
            DataTradeMode = new[] { dataTradeMode };
            Exchange = exchange;
-            NextPageToken = nextPageToken;
+            NextPageRequest = nextPageToken;
        }

        /// <summary>
@@ -74,7 +74,7 @@ namespace CryptoExchange.Net.SharedApis
            string exchange,
            TradingMode[]? dataTradeModes,
            WebCallResult<T> result,
-            INextPageToken? nextPageToken = null) :
+            PageRequest? nextPageRequest = null) :
            base(result.ResponseStatusCode,
                result.HttpVersion,
                result.ResponseHeaders,
@@ -92,7 +92,7 @@ namespace CryptoExchange.Net.SharedApis
        {
            DataTradeMode = dataTradeModes;
            Exchange = exchange;
-            NextPageToken = nextPageToken;
+            NextPageRequest = nextPageRequest;
        }

        /// <summary>
@@ -115,7 +115,7 @@ namespace CryptoExchange.Net.SharedApis
            ResultDataSource dataSource,
            [AllowNull] T data,
            Error? error,
-            INextPageToken? nextPageToken = null) : base(
+            PageRequest? nextPageToken = null) : base(
                code,
                httpVersion,
                responseHeaders,
@@ -133,7 +133,7 @@ namespace CryptoExchange.Net.SharedApis
        {
            DataTradeMode = dataTradeModes;
            Exchange = exchange;
-            NextPageToken = nextPageToken;
+            NextPageRequest = nextPageToken;
        }

        /// <summary>
@@ -144,7 +144,7 @@ namespace CryptoExchange.Net.SharedApis
        /// <returns></returns>
        public new ExchangeWebResult<K> As<K>([AllowNull] K data)
        {
-            return new ExchangeWebResult<K>(Exchange, DataTradeMode, ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, data, Error, NextPageToken);
+            return new ExchangeWebResult<K>(Exchange, DataTradeMode, ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, data, Error, NextPageRequest);
        }

        /// <inheritdoc />
@@ -1,4 +1,5 @@
 using CryptoExchange.Net.Objects;
+using System;
 using System.Text;

 namespace CryptoExchange.Net.SharedApis
@@ -8,24 +9,36 @@ namespace CryptoExchange.Net.SharedApis
    /// </summary>
    public class GetClosedOrdersOptions : PaginatedEndpointOptions<GetClosedOrdersRequest>
    {
-        /// <summary>
-        /// Whether the start/end time filter is supported
-        /// </summary>
-        public bool TimeFilterSupported { get; set; }
-
        /// <summary>
        /// ctor
        /// </summary>
-        public GetClosedOrdersOptions(SharedPaginationSupport paginationType, bool timeFilterSupported, int maxLimit) : base(paginationType, timeFilterSupported, maxLimit, true)
+        public GetClosedOrdersOptions(bool supportsAscending, bool supportsDescending, bool timeFilterSupported, int maxLimit) 
+            : base(supportsAscending, supportsDescending, timeFilterSupported, maxLimit, true)
        {
-            TimeFilterSupported = timeFilterSupported;
        }

        /// <inheritdoc />
        public override Error? ValidateRequest(string exchange, GetClosedOrdersRequest request, TradingMode? tradingMode, TradingMode[] supportedApiTypes)
        {
-            if (!TimeFilterSupported && request.StartTime != null)
-                return ArgumentError.Invalid(nameof(GetClosedOrdersRequest.StartTime), $"Time filter is not supported");
+            if (!SupportsAscending && request.Direction == DataDirection.Ascending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Ascending direction is not supported");
+
+            if (!SupportsDescending && request.Direction == DataDirection.Descending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Descending direction is not supported");
+
+            if (MaxAge.HasValue && request.StartTime < DateTime.UtcNow.Add(-MaxAge.Value))
+                return ArgumentError.Invalid(nameof(GetKlinesRequest.StartTime), $"Only the most recent {MaxAge} period data is available");
+
+            if (!TimePeriodFilterSupport)
+            {
+                // When going descending we can still allow startTime filter to limit the results
+                var now = DateTime.UtcNow;
+                if ((request.Direction != DataDirection.Descending && request.StartTime != null)
+                    || (request.EndTime != null && now - request.EndTime > TimeSpan.FromSeconds(5)))
+                {
+                    return ArgumentError.Invalid(nameof(GetDepositsRequest.StartTime), $"Time filter is not supported");
+                }
+            }

            return base.ValidateRequest(exchange, request, tradingMode, supportedApiTypes);
        }
@@ -34,7 +47,7 @@ namespace CryptoExchange.Net.SharedApis
        public override string ToString(string exchange)
        {
            var sb = new StringBuilder(base.ToString(exchange));
-            sb.AppendLine($"Time filter supported: {TimeFilterSupported}");
+            sb.AppendLine($"Time filter supported: {TimePeriodFilterSupport}");
            return sb.ToString();
        }
    }
@@ -1,4 +1,5 @@
 using CryptoExchange.Net.Objects;
+using System;
 using System.Text;

 namespace CryptoExchange.Net.SharedApis
@@ -8,24 +9,36 @@ namespace CryptoExchange.Net.SharedApis
    /// </summary>
    public class GetDepositsOptions : PaginatedEndpointOptions<GetDepositsRequest>
    {
-        /// <summary>
-        /// Whether the start/end time filter is supported
-        /// </summary>
-        public bool TimeFilterSupported { get; set; }
-
        /// <summary>
        /// ctor
        /// </summary>
-        public GetDepositsOptions(SharedPaginationSupport paginationType, bool timeFilterSupported, int maxLimit) : base(paginationType, timeFilterSupported, maxLimit, true)
+        public GetDepositsOptions(bool supportsAscending, bool supportsDescending, bool timeFilterSupported, int maxLimit) 
+            : base(supportsAscending, supportsDescending, timeFilterSupported, maxLimit, true)
        {
-            TimeFilterSupported = timeFilterSupported;
        }

        /// <inheritdoc />
        public override Error? ValidateRequest(string exchange, GetDepositsRequest request, TradingMode? tradingMode, TradingMode[] supportedApiTypes)
        {
-            if (!TimeFilterSupported && request.StartTime != null)
-                return ArgumentError.Invalid(nameof(GetDepositsRequest.StartTime), $"Time filter is not supported");
+            if (!SupportsAscending && request.Direction == DataDirection.Ascending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Ascending direction is not supported");
+
+            if (!SupportsDescending && request.Direction == DataDirection.Descending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Descending direction is not supported");
+
+            if (MaxAge.HasValue && request.StartTime < DateTime.UtcNow.Add(-MaxAge.Value))
+                return ArgumentError.Invalid(nameof(GetKlinesRequest.StartTime), $"Only the most recent {MaxAge} period data is available");
+
+            if (!TimePeriodFilterSupport)
+            {
+                // When going descending we can still allow startTime filter to limit the results
+                var now = DateTime.UtcNow;
+                if ((request.Direction != DataDirection.Descending && request.StartTime != null)
+                    || (request.EndTime != null && now - request.EndTime > TimeSpan.FromSeconds(5)))
+                {
+                    return ArgumentError.Invalid(nameof(GetDepositsRequest.StartTime), $"Time filter is not supported");
+                }
+            }

            return base.ValidateRequest(exchange, request, tradingMode, supportedApiTypes);
        }
@@ -34,7 +47,7 @@ namespace CryptoExchange.Net.SharedApis
        public override string ToString(string exchange)
        {
            var sb = new StringBuilder(base.ToString(exchange));
-            sb.AppendLine($"Time filter supported: {TimeFilterSupported}");
+            sb.AppendLine($"Time filter supported: {TimePeriodFilterSupport}");
            return sb.ToString();
        }
    }
@@ -1,4 +1,8 @@
-namespace CryptoExchange.Net.SharedApis
+using CryptoExchange.Net.Objects;
+using System;
+using System.Text;
+
+namespace CryptoExchange.Net.SharedApis
 {
    /// <summary>
    /// Options for requesting funding rate history
@@ -8,8 +12,43 @@
        /// <summary>
        /// ctor
        /// </summary>
-        public GetFundingRateHistoryOptions(SharedPaginationSupport paginationType, bool timeFilterSupported, int maxLimit, bool needsAuthentication) : base(paginationType, timeFilterSupported, maxLimit, needsAuthentication)
+        public GetFundingRateHistoryOptions(bool supportsAscending, bool supportsDescending, bool timeFilterSupported, int maxLimit, bool needsAuthentication) 
+            : base(supportsAscending, supportsDescending, timeFilterSupported, maxLimit, needsAuthentication)
        {
        }
+
+        /// <inheritdoc />
+        public override Error? ValidateRequest(string exchange, GetFundingRateHistoryRequest request, TradingMode? tradingMode, TradingMode[] supportedApiTypes)
+        {
+            if (!SupportsAscending && request.Direction == DataDirection.Ascending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Ascending direction is not supported");
+
+            if (!SupportsDescending && request.Direction == DataDirection.Descending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Descending direction is not supported");
+
+            if (MaxAge.HasValue && request.StartTime < DateTime.UtcNow.Add(-MaxAge.Value))
+                return ArgumentError.Invalid(nameof(GetKlinesRequest.StartTime), $"Only the most recent {MaxAge} period data is available");
+
+            if (!TimePeriodFilterSupport)
+            {
+                // When going descending we can still allow startTime filter to limit the results
+                var now = DateTime.UtcNow;
+                if ((request.Direction != DataDirection.Descending && request.StartTime != null)
+                    || (request.EndTime != null && now - request.EndTime > TimeSpan.FromSeconds(5)))
+                {
+                    return ArgumentError.Invalid(nameof(GetDepositsRequest.StartTime), $"Time filter is not supported");
+                }
+            }
+
+            return base.ValidateRequest(exchange, request, tradingMode, supportedApiTypes);
+        }
+
+        /// <inheritdoc />
+        public override string ToString(string exchange)
+        {
+            var sb = new StringBuilder(base.ToString(exchange));
+            sb.AppendLine($"Time filter supported: {TimePeriodFilterSupport}");
+            return sb.ToString();
+        }
    }
 }
@@ -18,15 +18,12 @@ namespace CryptoExchange.Net.SharedApis
        /// Max number of data points which can be requested
        /// </summary>
        public int? MaxTotalDataPoints { get; set; }
-        /// <summary>
-        /// The max age of the data that can be requested
-        /// </summary>
-        public TimeSpan? MaxAge { get; set; }

        /// <summary>
        /// ctor
        /// </summary>
-        public GetKlinesOptions(SharedPaginationSupport paginationType, bool timeFilterSupported, int maxLimit, bool needsAuthentication) : base(paginationType, timeFilterSupported, maxLimit, needsAuthentication)
+        public GetKlinesOptions(bool supportsAscending, bool supportsDescending, bool timeFilterSupported, int maxLimit, bool needsAuthentication)
+            : base(supportsAscending, supportsDescending, timeFilterSupported, maxLimit, needsAuthentication)
        {
            SupportIntervals = new[]
            {
@@ -50,7 +47,8 @@ namespace CryptoExchange.Net.SharedApis
        /// <summary>
        /// ctor
        /// </summary>
-        public GetKlinesOptions(SharedPaginationSupport paginationType, bool timeFilterSupported, int maxLimit, bool needsAuthentication, params SharedKlineInterval[] intervals) : base(paginationType, timeFilterSupported, maxLimit, needsAuthentication)
+        public GetKlinesOptions(bool supportsAscending, bool supportsDescending, bool timeFilterSupported, int maxLimit, bool needsAuthentication, params SharedKlineInterval[] intervals) 
+            : base(supportsAscending, supportsDescending, timeFilterSupported, maxLimit, needsAuthentication)
        {
            SupportIntervals = intervals;
        }
@@ -68,12 +66,29 @@ namespace CryptoExchange.Net.SharedApis
            if (!IsSupported(request.Interval))
                return ArgumentError.Invalid(nameof(GetKlinesRequest.Interval), "Interval not supported");

+            if (!SupportsAscending && request.Direction == DataDirection.Ascending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Ascending direction is not supported");
+
+            if (!SupportsDescending && request.Direction == DataDirection.Descending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Descending direction is not supported");
+
            if (MaxAge.HasValue && request.StartTime < DateTime.UtcNow.Add(-MaxAge.Value))
                return ArgumentError.Invalid(nameof(GetKlinesRequest.StartTime), $"Only the most recent {MaxAge} klines are available");

            if (request.Limit > MaxLimit)
                return ArgumentError.Invalid(nameof(GetKlinesRequest.Limit), $"Only {MaxLimit} klines can be retrieved per request");

+            if (!TimePeriodFilterSupport)
+            {
+                // When going descending we can still allow startTime filter to limit the results
+                var now = DateTime.UtcNow;
+                if ((request.Direction == DataDirection.Ascending && request.StartTime != null)
+                    || (request.EndTime != null && now - request.EndTime > TimeSpan.FromSeconds(5)))
+                {
+                    return ArgumentError.Invalid(nameof(GetDepositsRequest.StartTime), $"Time filter is not supported");
+                }
+            }
+
            if (MaxTotalDataPoints.HasValue)
            {
                if (request.Limit > MaxTotalDataPoints.Value)
@@ -93,6 +108,7 @@ namespace CryptoExchange.Net.SharedApis
        public override string ToString(string exchange)
        {
            var sb = new StringBuilder(base.ToString(exchange));
+            sb.AppendLine($"Time filter supported: {TimePeriodFilterSupport}");
            sb.AppendLine($"Supported SharedKlineInterval values: {string.Join(", ", SupportIntervals)}");
            if (MaxAge != null)
                sb.AppendLine($"Max age of data: {MaxAge}");
@@ -1,4 +1,8 @@
-namespace CryptoExchange.Net.SharedApis
+using CryptoExchange.Net.Objects;
+using System;
+using System.Text;
+
+namespace CryptoExchange.Net.SharedApis
 {
    /// <summary>
    /// Options for requesting position history
@@ -8,8 +12,43 @@
        /// <summary>
        /// ctor
        /// </summary>
-        public GetPositionHistoryOptions(SharedPaginationSupport paginationType, bool timeFilterSupported, int maxLimit) : base(paginationType, timeFilterSupported, maxLimit, true)
+        public GetPositionHistoryOptions(bool supportsAscending, bool supportsDescending, bool timeFilterSupported, int maxLimit) 
+            : base(supportsAscending, supportsDescending, timeFilterSupported, maxLimit, true)
        {
        }
+
+        /// <inheritdoc />
+        public override Error? ValidateRequest(string exchange, GetPositionHistoryRequest request, TradingMode? tradingMode, TradingMode[] supportedApiTypes)
+        {
+            if (!SupportsAscending && request.Direction == DataDirection.Ascending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Ascending direction is not supported");
+
+            if (!SupportsDescending && request.Direction == DataDirection.Descending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Descending direction is not supported");
+
+            if (MaxAge.HasValue && request.StartTime < DateTime.UtcNow.Add(-MaxAge.Value))
+                return ArgumentError.Invalid(nameof(GetKlinesRequest.StartTime), $"Only the most recent {MaxAge} period data is available");
+
+            if (!TimePeriodFilterSupport)
+            {
+                // When going descending we can still allow startTime filter to limit the results
+                var now = DateTime.UtcNow;
+                if ((request.Direction != DataDirection.Descending && request.StartTime != null)
+                    || (request.EndTime != null && now - request.EndTime > TimeSpan.FromSeconds(5)))
+                {
+                    return ArgumentError.Invalid(nameof(GetDepositsRequest.StartTime), $"Time filter is not supported");
+                }
+            }
+
+            return base.ValidateRequest(exchange, request, tradingMode, supportedApiTypes);
+        }
+
+        /// <inheritdoc />
+        public override string ToString(string exchange)
+        {
+            var sb = new StringBuilder(base.ToString(exchange));
+            sb.AppendLine($"Time filter supported: {TimePeriodFilterSupport}");
+            return sb.ToString();
+        }
    }
 }
@@ -9,34 +9,27 @@ namespace CryptoExchange.Net.SharedApis
    /// </summary>
    public class GetTradeHistoryOptions : PaginatedEndpointOptions<GetTradeHistoryRequest>
    {
-        /// <summary>
-        /// The max age of data that can be requested
-        /// </summary>
-        public TimeSpan? MaxAge { get; set; }
-
        /// <summary>
        /// ctor
        /// </summary>
-        public GetTradeHistoryOptions(SharedPaginationSupport paginationType, bool timeFilterSupported, int maxLimit, bool needsAuthentication) : base(paginationType, timeFilterSupported, maxLimit, needsAuthentication)
+        public GetTradeHistoryOptions(bool supportsAscending, bool supportsDescending, bool timeFilterSupported, int maxLimit, bool needsAuthentication)
+            : base(supportsAscending, supportsDescending, timeFilterSupported, maxLimit, needsAuthentication)
        {
        }

        /// <inheritdoc />
        public override Error? ValidateRequest(string exchange, GetTradeHistoryRequest request, TradingMode? tradingMode, TradingMode[] supportedApiTypes)
        {
+            if (!SupportsAscending && request.Direction == DataDirection.Ascending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Ascending direction is not supported");
+
+            if (!SupportsDescending && request.Direction == DataDirection.Descending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Descending direction is not supported");
+
            if (MaxAge.HasValue && request.StartTime < DateTime.UtcNow.Add(-MaxAge.Value))
-                return ArgumentError.Invalid(nameof(GetTradeHistoryRequest.StartTime), $"Only the most recent {MaxAge} trades are available");
+                return ArgumentError.Invalid(nameof(GetKlinesRequest.StartTime), $"Only the most recent {MaxAge} period data is available");

            return base.ValidateRequest(exchange, request, tradingMode, supportedApiTypes);
        }
-
-        /// <inheritdoc />
-        public override string ToString(string exchange)
-        {
-            var sb = new StringBuilder(base.ToString(exchange));
-            if (MaxAge != null)
-                sb.AppendLine($"Max age of data: {MaxAge}");
-            return sb.ToString();
-        }
    }
 }
@@ -0,0 +1,54 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Text;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Options for requesting user trades
+    /// </summary>
+    public class GetUserTradesOptions : PaginatedEndpointOptions<GetUserTradesRequest>
+    {
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public GetUserTradesOptions(bool supportsAscending, bool supportsDescending, bool timeFilterSupported, int maxLimit) 
+            : base(supportsAscending, supportsDescending, timeFilterSupported, maxLimit, true)
+        {
+        }
+
+        /// <inheritdoc />
+        public override Error? ValidateRequest(string exchange, GetUserTradesRequest request, TradingMode? tradingMode, TradingMode[] supportedApiTypes)
+        {
+            if (!SupportsAscending && request.Direction == DataDirection.Ascending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Ascending direction is not supported");
+
+            if (!SupportsDescending && request.Direction == DataDirection.Descending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Descending direction is not supported");
+
+            if (MaxAge.HasValue && request.StartTime < DateTime.UtcNow.Add(-MaxAge.Value))
+                return ArgumentError.Invalid(nameof(GetKlinesRequest.StartTime), $"Only the most recent {MaxAge} period data is available");
+
+            if (!TimePeriodFilterSupport)
+            {
+                // When going descending we can still allow startTime filter to limit the results
+                var now = DateTime.UtcNow;
+                if ((request.Direction != DataDirection.Descending && request.StartTime != null)
+                    || (request.EndTime != null && now - request.EndTime > TimeSpan.FromSeconds(5)))
+                {
+                    return ArgumentError.Invalid(nameof(GetDepositsRequest.StartTime), $"Time filter is not supported");
+                }
+            }
+
+            return base.ValidateRequest(exchange, request, tradingMode, supportedApiTypes);
+        }
+
+        /// <inheritdoc />
+        public override string ToString(string exchange)
+        {
+            var sb = new StringBuilder(base.ToString(exchange));
+            sb.AppendLine($"Time filter supported: {TimePeriodFilterSupport}");
+            return sb.ToString();
+        }
+    }
+}
@@ -1,4 +1,5 @@
 using CryptoExchange.Net.Objects;
+using System;
 using System.Text;

 namespace CryptoExchange.Net.SharedApis
@@ -8,24 +9,36 @@ namespace CryptoExchange.Net.SharedApis
    /// </summary>
    public class GetWithdrawalsOptions : PaginatedEndpointOptions<GetWithdrawalsRequest>
    {
-        /// <summary>
-        /// Whether the start/end time filter is supported
-        /// </summary>
-        public bool TimeFilterSupported { get; set; }
-
        /// <summary>
        /// ctor
        /// </summary>
-        public GetWithdrawalsOptions(SharedPaginationSupport paginationType, bool timeFilterSupported, int maxLimit) : base(paginationType, timeFilterSupported, maxLimit, true)
+        public GetWithdrawalsOptions(bool supportsAscending, bool supportsDescending, bool timeFilterSupported, int maxLimit)
+            : base(supportsAscending, supportsDescending, timeFilterSupported, maxLimit, true)
        {
-            TimeFilterSupported = timeFilterSupported;
        }

        /// <inheritdoc />
        public override Error? ValidateRequest(string exchange, GetWithdrawalsRequest request, TradingMode? tradingMode, TradingMode[] supportedApiTypes)
        {
-            if (!TimeFilterSupported && request.StartTime != null)
-                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.StartTime), $"Time filter is not supported");
+            if (!SupportsAscending && request.Direction == DataDirection.Ascending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Ascending direction is not supported");
+
+            if (!SupportsDescending && request.Direction == DataDirection.Descending)
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.Direction), $"Descending direction is not supported");
+
+            if (MaxAge.HasValue && request.StartTime < DateTime.UtcNow.Add(-MaxAge.Value))
+                return ArgumentError.Invalid(nameof(GetKlinesRequest.StartTime), $"Only the most recent {MaxAge} period data is available");
+
+            if (!TimePeriodFilterSupport)
+            {
+                // When going descending we can still allow startTime filter to limit the results
+                var now = DateTime.UtcNow;
+                if ((request.Direction != DataDirection.Descending && request.StartTime != null)
+                    || (request.EndTime != null && now - request.EndTime > TimeSpan.FromSeconds(5)))
+                {
+                    return ArgumentError.Invalid(nameof(GetDepositsRequest.StartTime), $"Time filter is not supported");
+                }
+            }

            return base.ValidateRequest(exchange, request, tradingMode, supportedApiTypes);
        }
@@ -34,7 +47,7 @@ namespace CryptoExchange.Net.SharedApis
        public override string ToString(string exchange)
        {
            var sb = new StringBuilder(base.ToString(exchange));
-            sb.AppendLine($"Time filter supported: {TimeFilterSupported}");
+            sb.AppendLine($"Time filter supported: {TimePeriodFilterSupport}");
            return sb.ToString();
        }
    }
@@ -1,4 +1,5 @@
-using System.Diagnostics.CodeAnalysis;
+using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Text;

 namespace CryptoExchange.Net.SharedApis
@@ -14,9 +15,13 @@ namespace CryptoExchange.Net.SharedApis
 #endif
    {
        /// <summary>
-        /// Type of pagination supported
+        /// Whether ascending data retrieval and pagination is available
        /// </summary>
-        public SharedPaginationSupport PaginationSupport { get; }
+        public bool SupportsAscending { get; set; }
+        /// <summary>
+        /// Whether ascending data retrieval and pagination is available
+        /// </summary>
+        public bool SupportsDescending { get; set; }

        /// <summary>
        /// Whether filtering based on start/end time is supported
@@ -28,12 +33,23 @@ namespace CryptoExchange.Net.SharedApis
        /// </summary>
        public int MaxLimit { get; set; }

+        /// <summary>
+        /// Max age of data that can be requested
+        /// </summary>
+        public TimeSpan? MaxAge { get; set; }
+
        /// <summary>
        /// ctor
        /// </summary>
-        public PaginatedEndpointOptions(SharedPaginationSupport paginationType, bool timePeriodSupport, int maxLimit, bool needsAuthentication) : base(needsAuthentication)
+        public PaginatedEndpointOptions(
+            bool supportsAscending,
+            bool supportsDescending,
+            bool timePeriodSupport,
+            int maxLimit,
+            bool needsAuthentication) : base(needsAuthentication)
        {
-            PaginationSupport = paginationType;
+            SupportsAscending = supportsAscending;
+            SupportsDescending = supportsDescending;
            TimePeriodFilterSupport = timePeriodSupport;
            MaxLimit = maxLimit;
        }
@@ -42,9 +58,11 @@ namespace CryptoExchange.Net.SharedApis
        public override string ToString(string exchange)
        {
            var sb = new StringBuilder(base.ToString(exchange));
-            sb.AppendLine($"Pagination type: {PaginationSupport}");
+            sb.AppendLine($"Ascending retrieval supported: {SupportsAscending}");
+            sb.AppendLine($"Descending retrieval supported: {SupportsDescending}");
            sb.AppendLine($"Time period filter support: {TimePeriodFilterSupport}");
            sb.AppendLine($"Max limit: {MaxLimit}");
+            sb.AppendLine($"Max age: {MaxAge}");
            return sb.ToString();
        }
    }
@@ -0,0 +1,17 @@
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Data direction
+    /// </summary>
+    public enum DataDirection
+    {
+        /// <summary>
+        /// Old to new order
+        /// </summary>
+        Ascending,
+        /// <summary>
+        /// New to old order
+        /// </summary>
+        Descending
+    }
+}
@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Next page request info
+    /// </summary>
+    public class PageRequest
+    {
+        /// <summary>
+        /// Pagination cursor
+        /// </summary>
+        public string? Cursor { get; set; }
+        /// <summary>
+        /// Page number
+        /// </summary>
+        public int? Page { get; set; }
+        /// <summary>
+        /// Result offset
+        /// </summary>
+        public int? Offset { get; set; }
+        /// <summary>
+        /// From id filter
+        /// </summary>
+        public string? FromId { get; set; }
+        /// <summary>
+        /// Start time filter
+        /// </summary>
+        public DateTime? StartTime { get; set; }
+        /// <summary>
+        /// End time filter
+        /// </summary>
+        public DateTime? EndTime { get; set; }
+    }
+}
@@ -0,0 +1,405 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Pagination methods
+    /// </summary>
+    public static class Pagination
+    {
+        /// <summary>
+        /// Get pagination parameters
+        /// </summary>
+        /// <param name="direction">The data direction</param>
+        /// <param name="limit">Result limit</param>
+        /// <param name="requestStartTime">User request start time</param>
+        /// <param name="requestEndTime">User request end time</param>
+        /// <param name="paginationRequest">Provided page request</param>
+        /// <param name="setOtherTimeLimiter">Whether to set start time if direction is descending, or end time if direction is ascending</param>
+        /// <param name="maxPeriod">Max period the time filters can span</param>
+        /// <returns></returns>
+        public static PaginationParameters GetPaginationParameters(
+            DataDirection direction,
+            int limit,
+            DateTime? requestStartTime,
+            DateTime requestEndTime,
+            PageRequest? paginationRequest, 
+            bool setOtherTimeLimiter = true,
+            TimeSpan? maxPeriod = null
+            )
+        {
+            var startTime = paginationRequest?.StartTime ?? requestStartTime;
+            var endTime = paginationRequest?.EndTime ?? requestEndTime;
+            if (maxPeriod != null)
+            {
+                if (direction == DataDirection.Ascending)
+                {
+                    if (startTime == null)
+                    {
+                        startTime = endTime.Add(-maxPeriod.Value);
+                    }
+                    else
+                    {
+                        endTime = startTime.Value.Add(maxPeriod.Value);
+                        if (endTime > DateTime.UtcNow)
+                            endTime = DateTime.UtcNow;
+                    }
+                }
+                else
+                {
+                    startTime = endTime.Add(-maxPeriod.Value);
+                }
+            }
+
+            return new PaginationParameters
+            {
+                Limit = limit,
+                StartTime = direction == DataDirection.Ascending || setOtherTimeLimiter ? startTime : null,
+                EndTime = direction == DataDirection.Descending || setOtherTimeLimiter ? endTime : null,
+                Direction = direction,
+                FromId = paginationRequest?.FromId,
+                Offset = paginationRequest?.Offset,
+                Page = paginationRequest?.Page,
+                Cursor = paginationRequest?.Cursor
+            };
+        }
+
+        /// <summary>
+        /// Get the next page request parameters from result kline data
+        /// </summary>
+        /// <param name="nextPageRequest">Callback for returning the next page request</param>
+        /// <param name="resultCount">Number of results in data</param>
+        /// <param name="timestamps">Timestamps of the result data</param>
+        /// <param name="requestStartTime">User request start time</param>
+        /// <param name="requestEndTime">User request end time</param>
+        /// <param name="lastPaginationData">The last used pagination data</param>
+        /// <param name="interval">Kline interval</param>
+        /// <returns></returns>
+        public static PageRequest? GetNextPageRequestKlines(
+            Func<PageRequest?> nextPageRequest,
+            int resultCount,
+            IEnumerable<DateTime> timestamps,
+            DateTime? requestStartTime,
+            DateTime requestEndTime,
+            PaginationParameters lastPaginationData,
+            SharedKlineInterval interval
+            )
+        {
+            if (HasNextPageKlines(resultCount, timestamps, requestStartTime, requestEndTime, lastPaginationData.Limit, lastPaginationData.Direction, interval))
+            {
+                var result = nextPageRequest();
+                if (result != null)
+                {
+                    result.StartTime ??= lastPaginationData.StartTime;
+                    result.EndTime ??= lastPaginationData.EndTime;
+                    return result;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Get the next page request parameters from result data
+        /// </summary>
+        /// <param name="nextPageRequest">Callback for returning the next page request</param>
+        /// <param name="resultCount">Number of results in data</param>
+        /// <param name="timestamps">Timestamps of the result data</param>
+        /// <param name="requestStartTime">User request start time</param>
+        /// <param name="requestEndTime">User request end time</param>
+        /// <param name="lastPaginationData">The last used pagination data</param>
+        /// <param name="maxPeriod">Max period the time filters can span</param>
+        /// <param name="maxAge">Max age of the data</param>
+        /// <returns></returns>
+        public static PageRequest? GetNextPageRequest(
+            Func<PageRequest?> nextPageRequest,
+            int resultCount,
+            IEnumerable<DateTime> timestamps,
+            DateTime? requestStartTime,
+            DateTime requestEndTime,
+            PaginationParameters lastPaginationData,
+            TimeSpan? maxPeriod = null,
+            TimeSpan? maxAge = null
+            )
+        {
+            if (HasNextPage(resultCount, timestamps, requestStartTime, requestEndTime, lastPaginationData.Limit, lastPaginationData.Direction))
+            {
+                var result = nextPageRequest();
+                if (result != null) 
+                {
+                    result.StartTime ??= lastPaginationData.StartTime;
+                    result.EndTime ??= lastPaginationData.EndTime;
+                    return result;
+                }
+            }
+
+            if (maxPeriod != null)
+            {
+                if (HasNextPeriod(requestStartTime, requestEndTime, lastPaginationData.Direction, lastPaginationData, maxPeriod.Value, maxAge))
+                {
+                    var (startTime, endTime) = GetNextPeriod(requestStartTime, requestEndTime, lastPaginationData.Direction, lastPaginationData, maxPeriod.Value, maxAge);
+                    return new PageRequest
+                    {
+                        StartTime = startTime,
+                        EndTime = endTime
+                    };
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Check whether there is (potentially) another page available 
+        /// </summary>
+        /// <param name="resultCount">Number of result entries</param>
+        /// <param name="timestamps">Timestamps</param>
+        /// <param name="requestStartTime">User request start time</param>
+        /// <param name="requestEndTime">User request end time</param>
+        /// <param name="limit">Max number of results requested</param>
+        /// <param name="direction">Data direction</param>
+        /// <param name="interval">Kline interval</param>
+        /// <returns></returns>
+        public static bool HasNextPageKlines(
+            int resultCount,
+            IEnumerable<DateTime> timestamps,
+            DateTime? requestStartTime,
+            DateTime requestEndTime,
+            int limit,
+            DataDirection direction,
+            SharedKlineInterval interval
+            )
+        {
+            if (resultCount < limit)
+                return false;
+
+            if (direction == DataDirection.Ascending)
+            {
+                if (timestamps.Max().AddSeconds((int)interval) >= requestEndTime)
+                    return false;
+
+                return true;
+            }
+            else
+            {
+                if (timestamps.Min().AddSeconds((int)interval) < requestStartTime)
+                    return false;
+
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Check whether there is (potentially) another page available 
+        /// </summary>
+        /// <param name="resultCount">Number of result entries</param>
+        /// <param name="timestamps">Timestamps</param>
+        /// <param name="requestStartTime">User request start time</param>
+        /// <param name="requestEndTime">User request end time</param>
+        /// <param name="limit">Max number of results requested</param>
+        /// <param name="direction">Data direction</param>
+        /// <returns></returns>
+        public static bool HasNextPage(
+            int resultCount,
+            IEnumerable<DateTime> timestamps,
+            DateTime? requestStartTime,
+            DateTime requestEndTime,
+            int limit,
+            DataDirection direction)
+        {
+            if (resultCount < limit)
+                return false;
+
+            if (!timestamps.Any())
+                return false;
+
+            if (direction == DataDirection.Ascending)
+            {
+                if (timestamps.Max() >= requestEndTime)
+                    return false;
+
+                return true;
+            }
+            else
+            {
+                if (timestamps.Min() < requestStartTime)
+                    return false;
+
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Get the next page PageRequest
+        /// </summary>
+        public static PageRequest NextPageFromPage(PaginationParameters lastPaginationData)
+        {
+            return new PageRequest { Page = (lastPaginationData.Page ?? 1) + 1 };
+        }
+        /// <summary>
+        /// Get the next offset PageRequest
+        /// </summary>
+        public static PageRequest NextPageFromOffset(PaginationParameters lastPaginationData, int resultCount)
+        {
+            return new PageRequest { Offset = (lastPaginationData.Offset ?? 0) + resultCount };
+        }
+        /// <summary>
+        /// Get the next page cursor PageRequest
+        /// </summary>
+        public static PageRequest NextPageFromCursor(string nextCursor)
+        {
+            return new PageRequest { Cursor = nextCursor };
+        }
+        /// <summary>
+        /// Get the next id PageRequest
+        /// </summary>
+        public static PageRequest NextPageFromId(long nextFromId)
+        {
+            return new PageRequest { FromId = nextFromId.ToString() };
+        }
+        /// <summary>
+        /// Get the next id PageRequest
+        /// </summary>
+        public static PageRequest NextPageFromId(string nextFromId)
+        {
+            return new PageRequest { FromId = nextFromId };
+        }
+        /// <summary>
+        /// Get the next start/end time PageRequest
+        /// </summary>
+        public static PageRequest NextPageFromTime(PaginationParameters lastPaginationData, DateTime lastTimestamp, bool setOtherTimeLimiter = true)
+        {
+            if (lastPaginationData.Direction == DataDirection.Ascending)
+                return new PageRequest { StartTime = lastTimestamp.AddMilliseconds(1), EndTime = setOtherTimeLimiter ? lastPaginationData.EndTime : null  };
+            else
+                return new PageRequest { EndTime = lastTimestamp.AddMilliseconds(-1), StartTime = setOtherTimeLimiter ? lastPaginationData.StartTime : null };
+        }
+
+        /// <summary>
+        /// Get the next start/end time klines PageRequest
+        /// </summary>
+        public static PageRequest NextPageFromTimeKlines(DataDirection direction, GetKlinesRequest request, DateTime lastTimestamp, int limit)
+        {
+            if (direction == DataDirection.Ascending)
+            {
+                var nextStartTime = lastTimestamp.AddSeconds((int)request.Interval);
+                var endTime = nextStartTime.AddSeconds(limit * (int)request.Interval);
+                var requestEndTime = request.EndTime ?? DateTime.UtcNow;
+                if (endTime > requestEndTime)
+                    endTime = requestEndTime;
+
+                return new PageRequest { StartTime = nextStartTime, EndTime = endTime };
+            }
+            else
+            {
+                var nextEndTime = lastTimestamp.AddSeconds(-(int)request.Interval);
+                var startTime = nextEndTime.AddSeconds(-(limit * (int)request.Interval));
+                var requestStartTime = request.StartTime ?? DateTime.UtcNow;
+                if (startTime < requestStartTime)
+                    startTime = requestStartTime;
+                return new PageRequest { StartTime = startTime, EndTime = nextEndTime };
+            }
+        }
+
+        /// <summary>
+        /// Whether another time period is to be requested 
+        /// </summary>
+        /// <param name="requestStartTime">User request start time</param>
+        /// <param name="requestEndTime">User request end time</param>
+        /// <param name="direction">Data direction</param>
+        /// <param name="lastPaginationParameters">Pagination parameters used</param>
+        /// <param name="period">Max time period a request can span</param>
+        /// <param name="maxAge">Max age of data that can be requested</param>
+        public static bool HasNextPeriod(
+            DateTime? requestStartTime,
+            DateTime requestEndTime,
+            DataDirection direction,
+            PaginationParameters lastPaginationParameters,
+            TimeSpan period,
+            TimeSpan? maxAge)
+        {
+            if (direction == DataDirection.Ascending && lastPaginationParameters.StartTime == null)
+                throw new InvalidOperationException("Invalid pagination data; no start time for ascending pagination");
+
+            if (direction == DataDirection.Ascending)
+            {
+                return (requestEndTime - lastPaginationParameters.EndTime!.Value).TotalSeconds > 1;
+            }
+            else
+            {
+                var lastPageStartTime = lastPaginationParameters.StartTime ?? lastPaginationParameters.EndTime!.Value.Add(-period);
+                if (requestStartTime != null)
+                {
+                    var nextPeriodDuration = lastPageStartTime - requestStartTime.Value;
+                    return nextPeriodDuration.TotalSeconds > 1;
+                }
+                else
+                {
+                    var nextStartTime = lastPageStartTime - period;
+                    if (maxAge != null)
+                    {
+                        var minStartTime = DateTime.UtcNow - maxAge.Value;
+                        if ((nextStartTime.Add(period) - minStartTime).TotalSeconds < 1)
+                            return false;
+                    }
+
+                    var nextPeriodDuration = lastPageStartTime - nextStartTime;
+                    return (nextPeriodDuration).TotalSeconds > 1;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get the start/end time for the next data period
+        /// </summary>
+        /// <param name="requestStartTime">User request start time</param>
+        /// <param name="requestEndTime">User request end time</param>
+        /// <param name="direction">Data direction</param>
+        /// <param name="lastPaginationParameters">Pagination parameters used</param>
+        /// <param name="period">Max time period a request can span</param>
+        /// <param name="maxAge">Max age of data that can be requested</param>
+        public static (DateTime? startTime, DateTime? endTime) GetNextPeriod(
+            DateTime? requestStartTime,
+            DateTime requestEndTime,
+            DataDirection direction,
+            PaginationParameters lastPaginationParameters,
+            TimeSpan period,
+            TimeSpan? maxAge
+            )
+        {
+            DateTime? nextStartTime = null;
+            DateTime? nextEndTime = null;
+            if (direction == DataDirection.Ascending)
+            {
+                if (lastPaginationParameters.StartTime != null)
+                    nextStartTime = lastPaginationParameters.StartTime.Value.Add(period);
+                if (lastPaginationParameters.EndTime != null)
+                    nextEndTime = lastPaginationParameters.EndTime.Value.Add(period);
+            }
+            else
+            {
+                if (lastPaginationParameters.StartTime != null)
+                    nextStartTime = lastPaginationParameters.StartTime.Value.Add(-period);
+                if (lastPaginationParameters.EndTime != null)
+                    nextEndTime = lastPaginationParameters.EndTime.Value.Add(-period);
+            }
+
+            if (nextStartTime != null && nextStartTime < requestStartTime)
+                nextStartTime = requestStartTime;
+
+            if (nextStartTime != null && maxAge != null && nextStartTime < DateTime.UtcNow - maxAge)
+            {
+                nextStartTime = DateTime.UtcNow.Add(-maxAge.Value);
+                // Add 30 seconds to max sure the client/server time offset and latency doesn't push the timestamp over the limit
+                nextStartTime = nextStartTime.Value.Add(TimeSpan.FromSeconds(30));
+            }
+
+            if (nextEndTime != null && nextEndTime > requestEndTime)
+                nextEndTime = requestEndTime;
+
+            return (nextStartTime, nextEndTime);
+        }
+    }
+}
@@ -0,0 +1,43 @@
+using System;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Pagination parameters
+    /// </summary>
+    public record PaginationParameters
+    {
+        /// <summary>
+        /// Data direction
+        /// </summary>
+        public DataDirection Direction { get; set; }
+        /// <summary>
+        /// Start time filter
+        /// </summary>
+        public DateTime? StartTime { get; set; }
+        /// <summary>
+        /// End time filter
+        /// </summary>
+        public DateTime? EndTime { get; set; }
+        /// <summary>
+        /// Id filter
+        /// </summary>
+        public string? FromId { get; set; }
+        /// <summary>
+        /// Result offset
+        /// </summary>
+        public int? Offset { get; set; }
+        /// <summary>
+        /// Page number
+        /// </summary>
+        public int? Page { get; set; }
+        /// <summary>
+        /// Pagination cursor
+        /// </summary>
+        public string? Cursor { get; set; }
+        /// <summary>
+        /// Max number of results
+        /// </summary>
+        public int Limit { get; set; }
+    }
+}
@@ -19,6 +19,10 @@ namespace CryptoExchange.Net.SharedApis
        /// Max number of results
        /// </summary>
        public int? Limit { get; }
+        /// <summary>
+        /// Data direction
+        /// </summary>
+        public DataDirection? Direction { get; set; }

        /// <summary>
        /// ctor
@@ -27,12 +31,14 @@ namespace CryptoExchange.Net.SharedApis
        /// <param name="startTime">Filter by start time</param>
        /// <param name="endTime">Filter by end time</param>
        /// <param name="limit">Max number of results</param>
+        /// <param name="direction">Data direction</param>
        /// <param name="exchangeParameters">Exchange specific parameters</param>
-        public GetClosedOrdersRequest(SharedSymbol symbol, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, ExchangeParameters? exchangeParameters = null) : base(symbol, exchangeParameters)
+        public GetClosedOrdersRequest(SharedSymbol symbol, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, DataDirection? direction = null, ExchangeParameters? exchangeParameters = null) : base(symbol, exchangeParameters)
        {
            StartTime = startTime;
            EndTime = endTime;
            Limit = limit;
+            Direction = direction;
        }
    }
 }
@@ -23,6 +23,10 @@ namespace CryptoExchange.Net.SharedApis
        /// Max number of results
        /// </summary>
        public int? Limit { get; }
+        /// <summary>
+        /// Data direction
+        /// </summary>
+        public DataDirection? Direction { get; set; }

        /// <summary>
        /// ctor
@@ -31,13 +35,15 @@ namespace CryptoExchange.Net.SharedApis
        /// <param name="startTime">Filter by start time</param>
        /// <param name="endTime">Filter by end time</param>
        /// <param name="limit">Max number of results</param>
+        /// <param name="direction">Data direction</param>
        /// <param name="exchangeParameters">Exchange specific parameters</param>
-        public GetDepositsRequest(string? asset = null, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, ExchangeParameters? exchangeParameters = null) : base(exchangeParameters)
+        public GetDepositsRequest(string? asset = null, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, DataDirection? direction = null, ExchangeParameters? exchangeParameters = null) : base(exchangeParameters)
        {
            Asset = asset;
            StartTime = startTime;
            EndTime = endTime;
            Limit = limit;
+            Direction = direction;
        }
    }
 }
@@ -19,6 +19,10 @@ namespace CryptoExchange.Net.SharedApis
        /// Max number of results
        /// </summary>
        public int? Limit { get; set; }
+        /// <summary>
+        /// Data direction
+        /// </summary>
+        public DataDirection? Direction { get; set; }

        /// <summary>
        /// ctor
@@ -27,12 +31,14 @@ namespace CryptoExchange.Net.SharedApis
        /// <param name="startTime">Filter by start time</param>
        /// <param name="endTime">Filter by end time</param>
        /// <param name="limit">Max number of results</param>
+        /// <param name="direction">Data direction</param>
        /// <param name="exchangeParameters">Exchange specific parameters</param>
-        public GetFundingRateHistoryRequest(SharedSymbol symbol, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, ExchangeParameters? exchangeParameters = null) : base(symbol, exchangeParameters)
+        public GetFundingRateHistoryRequest(SharedSymbol symbol, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, DataDirection? direction = null, ExchangeParameters? exchangeParameters = null) : base(symbol, exchangeParameters)
        {
            StartTime = startTime;
            EndTime = endTime;
            Limit = limit;
+            Direction = direction;
        }
    }
 }
@@ -23,6 +23,10 @@ namespace CryptoExchange.Net.SharedApis
        /// Max number of results
        /// </summary>
        public int? Limit { get; set; }
+        /// <summary>
+        /// Data direction
+        /// </summary>
+        public DataDirection? Direction { get; set; }

        /// <summary>
        /// ctor
@@ -32,13 +36,15 @@ namespace CryptoExchange.Net.SharedApis
        /// <param name="startTime">Filter by start time</param>
        /// <param name="endTime">Filter by end time</param>
        /// <param name="limit">Max number of results</param>
+        /// <param name="direction">Data direction</param>
        /// <param name="exchangeParameters">Exchange specific parameters</param>
-        public GetKlinesRequest(SharedSymbol symbol, SharedKlineInterval interval, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, ExchangeParameters? exchangeParameters = null) : base(symbol, exchangeParameters)
+        public GetKlinesRequest(SharedSymbol symbol, SharedKlineInterval interval, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, DataDirection? direction = null, ExchangeParameters? exchangeParameters = null) : base(symbol, exchangeParameters)
        {
            Interval = interval;
            StartTime = startTime;
            EndTime = endTime;
            Limit = limit;
+            Direction = direction;
        }
    }
 }
@@ -27,6 +27,10 @@ namespace CryptoExchange.Net.SharedApis
        /// Max number of results
        /// </summary>
        public int? Limit { get; set; }
+        /// <summary>
+        /// Data direction
+        /// </summary>
+        public DataDirection? Direction { get; set; }

        /// <summary>
        /// ctor
@@ -35,13 +39,15 @@ namespace CryptoExchange.Net.SharedApis
        /// <param name="startTime">Filter by start time</param>
        /// <param name="endTime">Filter by end time</param>
        /// <param name="limit">Max number of results</param>
+        /// <param name="direction">Data direction</param>
        /// <param name="exchangeParameters">Exchange specific parameters</param>
-        public GetPositionHistoryRequest(SharedSymbol symbol, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, ExchangeParameters? exchangeParameters = null) : base(exchangeParameters)
+        public GetPositionHistoryRequest(SharedSymbol symbol, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, DataDirection? direction = null, ExchangeParameters? exchangeParameters = null) : base(exchangeParameters)
        {
            Symbol = symbol;
            StartTime = startTime;
            EndTime = endTime;
            Limit = limit;
+            Direction = direction;
        }

        /// <summary>
@@ -51,13 +57,15 @@ namespace CryptoExchange.Net.SharedApis
        /// <param name="startTime">Filter by start time</param>
        /// <param name="endTime">Filter by end time</param>
        /// <param name="limit">Max number of results</param>
+        /// <param name="direction">Data direction</param>
        /// <param name="exchangeParameters">Exchange specific parameters</param>
-        public GetPositionHistoryRequest(TradingMode? tradeMode = null, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, ExchangeParameters? exchangeParameters = null) : base(exchangeParameters)
+        public GetPositionHistoryRequest(TradingMode? tradeMode = null, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, DataDirection? direction = null, ExchangeParameters? exchangeParameters = null) : base(exchangeParameters)
        {
            TradingMode = tradeMode;
            StartTime = startTime;
            EndTime = endTime;
            Limit = limit;
+            Direction = direction;
        }
    }
 }
@@ -10,15 +10,19 @@ namespace CryptoExchange.Net.SharedApis
        /// <summary>
        /// Filter by start time
        /// </summary>
-        public DateTime StartTime { get; }
+        public DateTime StartTime { get; set; }
        /// <summary>
        /// Filter by end time
        /// </summary>
-        public DateTime EndTime { get; }
+        public DateTime? EndTime { get; set; }
        /// <summary>
        /// Max number of results
        /// </summary>
-        public int? Limit { get; }
+        public int? Limit { get; set; }
+        /// <summary>
+        /// Data direction
+        /// </summary>
+        public DataDirection? Direction { get; set; }

        /// <summary>
        /// ctor
@@ -27,12 +31,14 @@ namespace CryptoExchange.Net.SharedApis
        /// <param name="startTime">Filter by start time</param>
        /// <param name="endTime">Filter by end time</param>
        /// <param name="limit">Max number of results</param>
+        /// <param name="direction">Data direction</param>
        /// <param name="exchangeParameters">Exchange specific parameters</param>
-        public GetTradeHistoryRequest(SharedSymbol symbol, DateTime startTime, DateTime endTime, int? limit = null, ExchangeParameters? exchangeParameters = null) : base(symbol, exchangeParameters)
+        public GetTradeHistoryRequest(SharedSymbol symbol, DateTime startTime, DateTime? endTime = null, int? limit = null, DataDirection? direction = null, ExchangeParameters? exchangeParameters = null) : base(symbol, exchangeParameters)
        {
            StartTime = startTime;
            EndTime = endTime;
            Limit = limit;
+            Direction = direction;
        }
    }
 }
@@ -19,6 +19,10 @@ namespace CryptoExchange.Net.SharedApis
        /// Max number of results
        /// </summary>
        public int? Limit { get; }
+        /// <summary>
+        /// Data direction
+        /// </summary>
+        public DataDirection? Direction { get; set; }

        /// <summary>
        /// ctor
@@ -27,12 +31,14 @@ namespace CryptoExchange.Net.SharedApis
        /// <param name="startTime">Filter by start time</param>
        /// <param name="endTime">Filter by end time</param>
        /// <param name="limit">Max number of results</param>
+        /// <param name="direction">Data direction</param>
        /// <param name="exchangeParameters">Exchange specific parameters</param>
-        public GetUserTradesRequest(SharedSymbol symbol, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, ExchangeParameters? exchangeParameters = null) : base(symbol, exchangeParameters)
+        public GetUserTradesRequest(SharedSymbol symbol, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, DataDirection? direction = null, ExchangeParameters? exchangeParameters = null) : base(symbol, exchangeParameters)
        {
            StartTime = startTime;
            EndTime = endTime;
            Limit = limit;
+            Direction = direction;
        }
    }
 }
@@ -23,6 +23,10 @@ namespace CryptoExchange.Net.SharedApis
        /// Max number of results
        /// </summary>
        public int? Limit { get; }
+        /// <summary>
+        /// Data direction
+        /// </summary>
+        public DataDirection? Direction { get; set; }

        /// <summary>
        /// ctor
@@ -31,13 +35,15 @@ namespace CryptoExchange.Net.SharedApis
        /// <param name="startTime">Filter by start time</param>
        /// <param name="endTime">Filter by end time</param>
        /// <param name="limit">Max number of results</param>
+        /// <param name="direction">Data direction</param>
        /// <param name="exchangeParameters">Exchange specific parameters</param>
-        public GetWithdrawalsRequest(string? asset = null, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, ExchangeParameters? exchangeParameters = null) : base(exchangeParameters)
+        public GetWithdrawalsRequest(string? asset = null, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, DataDirection? direction = null, ExchangeParameters? exchangeParameters = null) : base(exchangeParameters)
        {
            Asset = asset;
            StartTime = startTime; 
            EndTime = endTime; 
            Limit = limit;
+            Direction = direction;
        }
    }
 }
@@ -44,15 +44,21 @@ namespace CryptoExchange.Net.SharedApis
        /// </summary>
        public bool Completed { get; set; }

+        /// <summary>
+        /// Status of the deposit
+        /// </summary>
+        public SharedTransferStatus Status { get; set; }
+
        /// <summary>
        /// ctor
        /// </summary>
-        public SharedDeposit(string asset, decimal quantity, bool completed, DateTime timestamp)
+        public SharedDeposit(string asset, decimal quantity, bool completed, DateTime timestamp, SharedTransferStatus status)
        {
            Asset = asset;
            Quantity = quantity;
            Timestamp = timestamp;
            Completed = completed;
+            Status = status;
        }
    }

@@ -20,6 +20,10 @@ namespace CryptoExchange.Net.SharedApis
        /// </summary>
        public SharedPositionSide PositionSide { get; set; }
        /// <summary>
+        /// Whether the position is one way mode
+        /// </summary>
+        public SharedPositionMode PositionMode { get; set; }
+        /// <summary>
        /// Average open price
        /// </summary>
        public decimal? AverageOpenPrice { get; set; }
@@ -21,6 +21,11 @@ namespace CryptoExchange.Net.SharedApis
        /// </summary>
        public decimal? QuantityInContracts { get; set; }

+        /// <summary>
+        /// Whether all values are null or zero
+        /// </summary>
+        public bool IsZero => !(QuantityInBaseAsset > 0) && !(QuantityInQuoteAsset > 0) && !(QuantityInContracts > 0);
+
        /// <summary>
        /// ctor
        /// </summary>
@@ -49,7 +49,6 @@ namespace CryptoExchange.Net.Sockets.Default
        private int _reconnectAttempt;
        private readonly int _receiveBufferSize;

-        private const int _defaultReceiveBufferSize = 1048576;
        private const int _sendBufferSize = 4096;

        private int _bytesReceived = 0;
@@ -71,7 +70,7 @@ namespace CryptoExchange.Net.Sockets.Default
        /// <summary>
        /// The timestamp this socket has been active for the last time
        /// </summary>
-        public DateTime LastActionTime { get; private set; }
+        public DateTime? LastReceiveTime { get; private set; }
        
        /// <inheritdoc />
        public Uri Uri => Parameters.Uri;
@@ -88,16 +87,14 @@ namespace CryptoExchange.Net.Sockets.Default
            get
            {
                UpdateReceivedMessages();
-                return Math.Round(_prevSlotBytesReceived * (_lastBytesReceivedUpdate - _prevSlotBytesReceivedUpdate).TotalSeconds / 1000);
+                var seconds = (_lastBytesReceivedUpdate - _prevSlotBytesReceivedUpdate).TotalSeconds;
+                return seconds > 0 ? Math.Round(_prevSlotBytesReceived / seconds / 1000) : 0;
            }
        }

        /// <inheritdoc />
        public event Func<Task>? OnClose;

-        /// <inheritdoc />
-        public event Func<WebSocketMessageType, ReadOnlyMemory<byte>, Task>? OnStreamMessage;
-
        /// <inheritdoc />
        public event Func<int, Task>? OnRequestSent;

@@ -139,10 +136,7 @@ namespace CryptoExchange.Net.Sockets.Default
            _sendEvent = new AsyncResetEvent();
            _sendBuffer = new ConcurrentQueue<SendItem>();
            _ctsSource = new CancellationTokenSource();
-            if (websocketParameters.UseUpdatedDeserialization)
-                _receiveBufferSize = websocketParameters.ReceiveBufferSize ?? 65536;
-            else
-                _receiveBufferSize = websocketParameters.ReceiveBufferSize ?? _defaultReceiveBufferSize;
+            _receiveBufferSize = websocketParameters.ReceiveBufferSize ?? 65536;

            _closeSem = new SemaphoreSlim(1, 1);
            _socket = CreateSocket();
@@ -225,7 +219,9 @@ namespace CryptoExchange.Net.Sockets.Default
            catch (Exception e)
            {
                if (ct.IsCancellationRequested)
+                {
                    _logger.SocketConnectingCanceled(Id);
+                }
                else if (!_ctsSource.IsCancellationRequested)
                {
                    // if _ctsSource was canceled this was already logged
@@ -271,11 +267,10 @@ namespace CryptoExchange.Net.Sockets.Default
                var sendTask = SendLoopAsync();
                Task receiveTask;
 #if !NETSTANDARD2_0
-                if (Parameters.UseUpdatedDeserialization)
-                    receiveTask = ReceiveLoopNewAsync();
-                else
+                receiveTask = ReceiveLoopNewAsync();
+#else
+                receiveTask = ReceiveLoopAsync();
 #endif
-                    receiveTask = ReceiveLoopAsync();
                var timeoutTask = Parameters.Timeout != null && Parameters.Timeout > TimeSpan.FromSeconds(0) ? CheckTimeoutAsync() : Task.CompletedTask;
                await Task.WhenAll(sendTask, receiveTask, timeoutTask).ConfigureAwait(false);
                _logger.SocketFinishedProcessing(Id);
@@ -492,7 +487,6 @@ namespace CryptoExchange.Net.Sockets.Default
            _disposed = true;
            _socket.Dispose();
            _ctsSource?.Dispose();
-            _sendEvent.Dispose();
            _logger.SocketDisposed(Id);
        }

@@ -578,6 +572,7 @@ namespace CryptoExchange.Net.Sockets.Default
            }
        }

+#if NETSTANDARD2_0
        /// <summary>
        /// Loop for receiving and reassembling data
        /// </summary>
@@ -627,6 +622,7 @@ namespace CryptoExchange.Net.Sockets.Default
                            break;
                        }

+                        LastReceiveTime = DateTime.UtcNow;
                        if (receiveResult.MessageType == WebSocketMessageType.Close)
                        {
                            // Connection closed
@@ -666,10 +662,7 @@ namespace CryptoExchange.Net.Sockets.Default
                                if (_logger.IsEnabled(LogLevel.Trace))
                                    _logger.SocketReceivedSingleMessage(Id, receiveResult.Count);

-                                if (!Parameters.UseUpdatedDeserialization)
-                                    await ProcessData(receiveResult.MessageType, new ReadOnlyMemory<byte>(buffer.Array!, buffer.Offset, receiveResult.Count)).ConfigureAwait(false);
-                                else
-                                    ProcessDataNew(receiveResult.MessageType, new ReadOnlySpan<byte>(buffer.Array!, buffer.Offset, receiveResult.Count));
+                                ProcessDataNew(receiveResult.MessageType, new ReadOnlySpan<byte>(buffer.Array!, buffer.Offset, receiveResult.Count));
                            }
                            else
                            {
@@ -703,11 +696,7 @@ namespace CryptoExchange.Net.Sockets.Default
                                _logger.SocketReassembledMessage(Id, multipartStream!.Length);

                            // Get the underlying buffer of the memory stream holding the written data and delimit it (GetBuffer return the full array, not only the written part)
-
-                            if (!Parameters.UseUpdatedDeserialization)
-                                await ProcessData(receiveResult.MessageType, new ReadOnlyMemory<byte>(multipartStream!.GetBuffer(), 0, (int)multipartStream.Length)).ConfigureAwait(false);
-                            else
-                                ProcessDataNew(receiveResult.MessageType, new ReadOnlySpan<byte>(multipartStream!.GetBuffer(), 0, (int)multipartStream.Length));
+                             ProcessDataNew(receiveResult.MessageType, new ReadOnlySpan<byte>(multipartStream!.GetBuffer(), 0, (int)multipartStream.Length));
                        }
                        else
                        {
@@ -732,6 +721,7 @@ namespace CryptoExchange.Net.Sockets.Default
                _logger.SocketReceiveLoopFinished(Id);
            }
        }
+#endif

 #if !NETSTANDARD2_0
        /// <summary>
@@ -783,6 +773,7 @@ namespace CryptoExchange.Net.Sockets.Default
                            break;
                        }

+                        LastReceiveTime = DateTime.UtcNow;
                        if (receiveResult.MessageType == WebSocketMessageType.Close)
                        {
                            // Connection closed
@@ -891,22 +882,9 @@ namespace CryptoExchange.Net.Sockets.Default
        /// <returns></returns>
        protected void ProcessDataNew(WebSocketMessageType type, ReadOnlySpan<byte> data)
        {
-            LastActionTime = DateTime.UtcNow;
            _connection.HandleStreamMessage2(type, data);
        }

-        /// <summary>
-        /// Process a stream message
-        /// </summary>
-        /// <param name="type"></param>
-        /// <param name="data"></param>
-        /// <returns></returns>
-        protected async Task ProcessData(WebSocketMessageType type, ReadOnlyMemory<byte> data)
-        {
-            LastActionTime = DateTime.UtcNow;
-            await (OnStreamMessage?.Invoke(type, data) ?? Task.CompletedTask).ConfigureAwait(false);
-        }
-
        /// <summary>
        /// Checks if there is no data received for a period longer than the specified timeout
        /// </summary>
@@ -914,7 +892,7 @@ namespace CryptoExchange.Net.Sockets.Default
        protected async Task CheckTimeoutAsync()
        {
            _logger.SocketStartingTaskForNoDataReceivedCheck(Id, Parameters.Timeout);
-            LastActionTime = DateTime.UtcNow;
+            LastReceiveTime = DateTime.UtcNow;
            try 
            { 
                while (true)
@@ -922,7 +900,7 @@ namespace CryptoExchange.Net.Sockets.Default
                    if (_ctsSource.IsCancellationRequested)
                        return;

-                    if (DateTime.UtcNow - LastActionTime > Parameters.Timeout)
+                    if (DateTime.UtcNow - LastReceiveTime > Parameters.Timeout)
                    {
                        _logger.SocketNoDataReceiveTimoutReconnect(Id, Parameters.Timeout);
                        _ = ReconnectAsync().ConfigureAwait(false);
@@ -16,10 +16,6 @@ namespace CryptoExchange.Net.Sockets.Default.Interfaces
        /// </summary>
        event Func<Task> OnClose;
        /// <summary>
-        /// Websocket message received event
-        /// </summary>
-        event Func<WebSocketMessageType, ReadOnlyMemory<byte>, Task> OnStreamMessage;
-        /// <summary>
        /// Websocket sent event, RequestId as parameter
        /// </summary>
        event Func<int, Task> OnRequestSent;
@@ -73,6 +69,10 @@ namespace CryptoExchange.Net.Sockets.Default.Interfaces
        /// </summary>
        bool IsOpen { get; }
        /// <summary>
+        /// Last timestamp something was received from the server
+        /// </summary>
+        DateTime? LastReceiveTime { get; }
+        /// <summary>
        /// Connect the socket
        /// </summary>
        /// <returns></returns>
@@ -111,11 +111,6 @@ namespace CryptoExchange.Net.Sockets.Default
        /// </summary>
        public event Action? ActivityUnpaused;

-        /// <summary>
-        /// Unhandled message event
-        /// </summary>
-        public event Action<IMessageAccessor>? UnhandledMessage;
-
        /// <summary>
        /// Connection was rate limited and couldn't be established
        /// </summary>
@@ -128,8 +123,15 @@ namespace CryptoExchange.Net.Sockets.Default
        {
            get
            {
-                lock (_listenersLock)
+                try
+                {
+                    _listenersLock.EnterReadLock();
                    return _listeners.OfType<Subscription>().Count(h => h.UserSubscription);
+                }
+                finally
+                {
+                    _listenersLock.ExitReadLock();
+                }
            }
        }

@@ -140,8 +142,16 @@ namespace CryptoExchange.Net.Sockets.Default
        {
            get
            {
-                lock (_listenersLock)
+                try
+                {
+                    _listenersLock.EnterReadLock();
                    return _listeners.OfType<Subscription>().Where(h => h.UserSubscription).ToArray();
+
+                }
+                finally
+                {
+                    _listenersLock.ExitReadLock();
+                }
            }
        }

@@ -183,6 +193,11 @@ namespace CryptoExchange.Net.Sockets.Default
        /// </summary>
        public DateTime? DisconnectTime { get; set; }

+        /// <summary>
+        /// Last timestamp something was received from the server
+        /// </summary>
+        public DateTime? LastReceiveTime => _socket.LastReceiveTime;
+
        /// <summary>
        /// Tag for identification
        /// </summary>
@@ -240,8 +255,15 @@ namespace CryptoExchange.Net.Sockets.Default
        {
            get
            {
-                lock (_listenersLock)
+                try
+                {
+                    _listenersLock.EnterReadLock();
                    return _listeners.OfType<Subscription>().Select(x => x.Topic).Where(t => t != null).ToArray()!;
+                }
+                finally
+                {
+                    _listenersLock.ExitReadLock();
+                }
            }
        }

@@ -252,25 +274,26 @@ namespace CryptoExchange.Net.Sockets.Default
        {
            get
            {
-                lock (_listenersLock)
+                try
+                {
+                    _listenersLock.EnterReadLock();
                    return _listeners.OfType<Query>().Where(x => !x.Completed).Count();
+                }
+                finally
+                {
+                    _listenersLock.ExitReadLock();
+                }
            }
        }


        private bool _pausedActivity;
-#if NET9_0_OR_GREATER
-        private readonly Lock _listenersLock = new Lock();
-#else
-        private readonly object _listenersLock = new object();
-#endif
+        private readonly ReaderWriterLockSlim _listenersLock = new ReaderWriterLockSlim();
        private readonly List<IMessageProcessor> _listeners;
        private readonly ILogger _logger;
        private SocketStatus _status;

        private readonly IMessageSerializer _serializer;
-        private IByteMessageAccessor? _stringMessageAccessor;
-        private IByteMessageAccessor? _byteMessageAccessor;

        private ISocketMessageHandler? _byteMessageConverter;
        private ISocketMessageHandler? _textMessageConverter;
@@ -291,11 +314,6 @@ namespace CryptoExchange.Net.Sockets.Default
        /// The underlying websocket
        /// </summary>
        private readonly IWebsocket _socket;
-
-        /// <summary>
-        /// Cache for deserialization, only caches for a single message
-        /// </summary>
-        private readonly Dictionary<Type, object> _deserializationCache = new Dictionary<Type, object>();
        
        /// <summary>
        /// New socket connection
@@ -310,7 +328,6 @@ namespace CryptoExchange.Net.Sockets.Default
            _socket = socketFactory.CreateWebsocket(logger, this, parameters);
            _logger.SocketCreatedForAddress(_socket.Id, parameters.Uri.ToString());

-            _socket.OnStreamMessage += HandleStreamMessage;
            _socket.OnRequestSent += HandleRequestSentAsync;
            _socket.OnRequestRateLimited += HandleRequestRateLimitedAsync;
            _socket.OnConnectRateLimited += HandleConnectRateLimitedAsync;
@@ -348,8 +365,9 @@ namespace CryptoExchange.Net.Sockets.Default
            if (ApiClient._socketConnections.ContainsKey(SocketId))
                ApiClient._socketConnections.TryRemove(SocketId, out _);

-            lock (_listenersLock)
+            try
            {
+                _listenersLock.EnterWriteLock();
                foreach (var subscription in _listeners.OfType<Subscription>().Where(l => l.UserSubscription && !l.IsClosingConnection))
                {
                    subscription.IsClosingConnection = true;
@@ -362,6 +380,10 @@ namespace CryptoExchange.Net.Sockets.Default
                    _listeners.Remove(query);
                }
            }
+            finally
+            {
+                _listenersLock.ExitWriteLock();
+            }

            _ = Task.Run(() => ConnectionClosed?.Invoke());
            return Task.CompletedTask;
@@ -377,8 +399,9 @@ namespace CryptoExchange.Net.Sockets.Default
            Authenticated = false;
            _lastSequenceNumber = 0;

-            lock (_listenersLock)
+            try
            {
+                _listenersLock.EnterWriteLock();
                foreach (var subscription in _listeners.OfType<Subscription>().Where(l => l.UserSubscription))
                    subscription.Reset();

@@ -388,6 +411,10 @@ namespace CryptoExchange.Net.Sockets.Default
                    _listeners.Remove(query);
                }
            }
+            finally
+            {
+                _listenersLock.ExitWriteLock();
+            }

            _ = Task.Run(() => ConnectionLost?.Invoke());
            return Task.CompletedTask;
@@ -409,14 +436,19 @@ namespace CryptoExchange.Net.Sockets.Default
        {
            Status = SocketStatus.Resubscribing;

-            lock (_listenersLock)
+            try
            {
+                _listenersLock.EnterWriteLock();
                foreach (var query in _listeners.OfType<Query>().ToList())
                {
                    query.Fail(new WebError("Connection interrupted"));
                    _listeners.Remove(query);
                }
            }
+            finally
+            {
+                _listenersLock.ExitWriteLock();
+            }

            // Can't wait for this as it would cause a deadlock
            _ = Task.Run(async () =>
@@ -472,10 +504,15 @@ namespace CryptoExchange.Net.Sockets.Default
        protected virtual Task HandleRequestRateLimitedAsync(int requestId)
        {
            Query? query;
-            lock (_listenersLock)
+            try
            {
+                _listenersLock.EnterReadLock();
                query = _listeners.OfType<Query>().FirstOrDefault(x => x.Id == requestId);
            }
+            finally
+            {
+                _listenersLock.ExitReadLock();
+            }

            if (query == null)
                return Task.CompletedTask;
@@ -501,10 +538,15 @@ namespace CryptoExchange.Net.Sockets.Default
        protected virtual Task HandleRequestSentAsync(int requestId)
        {
            Query? query;
-            lock (_listenersLock)
+            try
            {
+                _listenersLock.EnterReadLock();
                query = _listeners.OfType<Query>().FirstOrDefault(x => x.Id == requestId);
            }
+            finally
+            {
+                _listenersLock.ExitReadLock();
+            }

            if (query == null)
                return Task.CompletedTask;
@@ -551,8 +593,9 @@ namespace CryptoExchange.Net.Sockets.Default
            }

            Type? deserializationType = null;
-            lock (_listenersLock)
+            try
            {
+                _listenersLock.EnterReadLock();
                foreach (var subscription in _listeners)
                {
                    foreach (var route in subscription.MessageRouter.Routes)
@@ -568,11 +611,19 @@ namespace CryptoExchange.Net.Sockets.Default
                        break;
                }
            }
+            finally
+            {
+                _listenersLock.ExitReadLock();
+            }

            if (deserializationType == null)
            {
-                // No handler found for identifier either, can't process
-                _logger.LogWarning("Failed to determine message type for identifier {Identifier}. Data: {Message}", typeIdentifier, Encoding.UTF8.GetString(data.ToArray()));
+                if (!ApiClient.HandleUnhandledMessage(this, typeIdentifier, data))
+                {
+                    // No handler found for identifier either, can't process
+                    _logger.LogWarning("Failed to determine message type for identifier {Identifier}. Data: {Message}", typeIdentifier, Encoding.UTF8.GetString(data.ToArray()));
+                }
+                    
                return;
            }
            
@@ -609,8 +660,9 @@ namespace CryptoExchange.Net.Sockets.Default
            var topicFilter = messageConverter.GetTopicFilter(result);

            bool processed = false;
-            lock (_listenersLock)
+            try
            {
+                _listenersLock.EnterReadLock();
                var currentCount = _listeners.Count;
                for(var i = 0; i < _listeners.Count; i++)
                {
@@ -637,171 +689,61 @@ namespace CryptoExchange.Net.Sockets.Default
                        if (route.TypeIdentifier != typeIdentifier)
                            continue;

-                        if (topicFilter == null
-                            || route.TopicFilter == null 
-                            || route.TopicFilter.Equals(topicFilter, StringComparison.Ordinal))
+                        // Forward message rules:
+                        // | Message Topic | Route Topic Filter | Topics Match | Forward | Description
+                        // |       N       |          N         |      -       |    Y    | No topic filter applied
+                        // |       N       |          Y         |      -       |    N    | Route only listens to specific topic
+                        // |       Y       |          N         |      -       |    Y    | Route listens to all message regardless of topic
+                        // |       Y       |          Y         |      Y       |    Y    | Route listens to specific message topic
+                        // |       Y       |          Y         |      N       |    N    | Route listens to different topic
+                        if (topicFilter == null)
                        {
-                            if (isQuery && query!.Completed)
+                            if (route.TopicFilter != null)
+                                // No topic on message, but route is filtering on topic
                                continue;
-
-                            processed = true;
-                            processor.Handle(this, receiveTime, originalData, result, route);
-
-                            if (isQuery && !route.MultipleReaders)
-                            {
-                                complete = true;
-                                break;
-                            }
                        }
+                        else
+                        {
+                            if (route.TopicFilter != null && !route.TopicFilter.Equals(topicFilter, StringComparison.Ordinal))
+                                // Message has a topic, and the route has a filter for another topic
+                                continue;
+                        }
+
+                        processed = true;
+
+                        if (isQuery && query!.Completed)
+                            continue;
+
+                        processor.Handle(this, receiveTime, originalData, result, route);
+                        if (isQuery && !route.MultipleReaders)
+                        {
+                            complete = true;
+                            break;
+                        }                        
                    }

                    if (complete)
                        break;
                }
            }
+            finally
+            {
+                _listenersLock.ExitReadLock();
+            }

            if (!processed)
            {
-                _logger.ReceivedMessageNotMatchedToAnyListener(SocketId, topicFilter!,
-                    string.Join(",", _listeners.Select(x => string.Join(",", x.MessageRouter.Routes.Select(x => x.TopicFilter != null ? string.Join(",", x.TopicFilter) : "[null]")))));
-            }
-        }
-
-        /// <summary>
-        /// Handle a message
-        /// </summary>
-        protected virtual async Task HandleStreamMessage(WebSocketMessageType type, ReadOnlyMemory<byte> data)
-        {
-            var sw = Stopwatch.StartNew();
-            var receiveTime = DateTime.UtcNow;
-            string? originalData = null;
-
-            // 1. Decrypt/Preprocess if necessary
-            data = ApiClient.PreprocessStreamMessage(this, type, data);
-
-            // 2. Read data into accessor
-            IByteMessageAccessor accessor;
-            if (type == WebSocketMessageType.Binary)
-                accessor = _stringMessageAccessor ??= ApiClient.CreateAccessor(type);
-            else
-                accessor = _byteMessageAccessor ??= ApiClient.CreateAccessor(type);
-
-            var result = accessor.Read(data);
-            try
-            {
-                bool outputOriginalData = ApiClient.ApiOptions.OutputOriginalData ?? ApiClient.ClientOptions.OutputOriginalData;
-                if (outputOriginalData)
+                if (!ApiClient.HandleUnhandledMessage(this, typeIdentifier, data))
                {
-                    originalData = accessor.GetOriginalString();
-                    _logger.ReceivedData(SocketId, originalData);
-                }
-
-                if (!accessor.IsValid && !ApiClient.ProcessUnparsableMessages)
-                {
-                    _logger.FailedToParse(SocketId, result.Error!.Message ?? result.Error!.ErrorDescription!);
-                    return;
-                }
-
-                // 3. Determine the identifying properties of this message
-                var listenId = ApiClient.GetListenerIdentifier(accessor);
-                if (listenId == null)
-                {
-                    originalData ??= "[OutputOriginalData is false]";
-                    if (!ApiClient.UnhandledMessageExpected)
-                        _logger.FailedToEvaluateMessage(SocketId, originalData);
-
-                    UnhandledMessage?.Invoke(accessor);
-                    return;
-                }
-
-                bool processed = false;
-                var totalUserTime = 0;
-
-                List<IMessageProcessor> localListeners;
-                lock (_listenersLock)
-                    localListeners = _listeners.ToList();
-
-                foreach (var processor in localListeners)
-                {
-                    foreach (var listener in processor.MessageMatcher.GetHandlerLinks(listenId))
+                    lock (_listenersLock)
                    {
-                        processed = true;
-                        _logger.ProcessorMatched(SocketId, listener.ToString(), listenId);
-
-                        // 4. Determine the type to deserialize to for this processor
-                        var messageType = listener.DeserializationType;
-                        if (messageType == null)
-                        {
-                            _logger.ReceivedMessageNotRecognized(SocketId, processor.Id);
-                            continue;
-                        }
-
-                        if (processor is Subscription subscriptionProcessor && subscriptionProcessor.Status == SubscriptionStatus.Subscribing)
-                        {
-                            // If this message is for this listener then it is automatically confirmed, even if the subscription is not (yet) confirmed
-                            subscriptionProcessor.Status = SubscriptionStatus.Subscribed;
-                            if (subscriptionProcessor.SubscriptionQuery?.TimeoutBehavior == TimeoutBehavior.Succeed)
-                                // If this subscription has a query waiting for a timeout (success if there is no error response)
-                                // then time it out now as the data is being received, so we assume it's successful
-                                subscriptionProcessor.SubscriptionQuery.Timeout();
-                        }
-
-                        // 5. Deserialize the message
-                        _deserializationCache.TryGetValue(messageType, out var deserialized);
-
-                        if (deserialized == null)
-                        {
-                            var desResult = processor.Deserialize(accessor, messageType);
-                            if (!desResult)
-                            {
-                                _logger.FailedToDeserializeMessage(SocketId, desResult.Error?.ToString(), desResult.Error?.Exception);
-                                continue;
-                            }
-
-                            deserialized = desResult.Data;
-                            _deserializationCache.Add(messageType, deserialized);
-                        }
-
-                        // 6. Pass the message to the handler
-                        try
-                        {
-                            var innerSw = Stopwatch.StartNew();
-                            processor.Handle(this, receiveTime, originalData, deserialized, listener);
-                            if (processor is Query query && query.RequiredResponses != 1)
-                                _logger.LogDebug($"[Sckt {SocketId}] [Req {query.Id}] responses: {query.CurrentResponses}/{query.RequiredResponses}");
-                            totalUserTime += (int)innerSw.ElapsedMilliseconds;
-                        }
-                        catch (Exception ex)
-                        {
-                            _logger.UserMessageProcessingFailed(SocketId, ex.Message, ex);
-                            if (processor is Subscription subscription)
-                                subscription.InvokeExceptionHandler(ex);
-                        }
-
+                        _logger.ReceivedMessageNotMatchedToAnyListener(
+                            SocketId,
+                            typeIdentifier,
+                            topicFilter!,
+                            string.Join(",", _listeners.Select(x => string.Join(",", x.MessageRouter.Routes.Where(x => x.TypeIdentifier == typeIdentifier).Select(x => x.TopicFilter != null ? string.Join(",", x.TopicFilter) : "[null]")))));
                    }
                }
-
-                if (!processed)
-                {
-                    if (!ApiClient.UnhandledMessageExpected)
-                    {
-                        List<string> listenerIds;
-                        lock (_listenersLock)
-                            listenerIds = _listeners.Select(l => l.MessageMatcher.ToString()).ToList();
-
-                        _logger.ReceivedMessageNotMatchedToAnyListener(SocketId, listenId, string.Join(",", listenerIds));
-                        UnhandledMessage?.Invoke(accessor);
-                    }
-
-                    return;
-                }
-
-                _logger.MessageProcessed(SocketId, sw.ElapsedMilliseconds, sw.ElapsedMilliseconds - totalUserTime);
-            }
-            finally
-            {
-                _deserializationCache.Clear();
-                accessor.Clear();
            }
        }

@@ -845,14 +787,19 @@ namespace CryptoExchange.Net.Sockets.Default
            if (ApiClient._socketConnections.ContainsKey(SocketId))
                ApiClient._socketConnections.TryRemove(SocketId, out _);

-            lock (_listenersLock)
+            try
            {
+                _listenersLock.EnterReadLock();
                foreach (var subscription in _listeners.OfType<Subscription>())
                {
                    if (subscription.CancellationTokenRegistration.HasValue)
                        subscription.CancellationTokenRegistration.Value.Dispose();
                }
            }
+            finally
+            {
+                _listenersLock.ExitReadLock();
+            }

            await _socket.CloseAsync().ConfigureAwait(false);
            _socket.Dispose();
@@ -882,26 +829,30 @@ namespace CryptoExchange.Net.Sockets.Default
                subscription.CancellationTokenRegistration.Value.Dispose();

            bool anyDuplicateSubscription;
-            if (ApiClient.ClientOptions.UseUpdatedDeserialization)
-            {
-                lock (_listenersLock)
-                    anyDuplicateSubscription = _listeners.OfType<Subscription>().Any(x => x != subscription && x.MessageRouter.Routes.All(l => subscription.MessageRouter.ContainsCheck(l)));
-            }
-            else
-            {
-                lock (_listenersLock)
-                    anyDuplicateSubscription = _listeners.OfType<Subscription>().Any(x => x != subscription && x.MessageMatcher.HandlerLinks.All(l => subscription.MessageMatcher.ContainsCheck(l)));
-            }
-
            bool shouldCloseConnection;
-            lock (_listenersLock)
+            try
+            {
+                _listenersLock.EnterReadLock();
+                anyDuplicateSubscription = _listeners.OfType<Subscription>().Any(x => x != subscription && x.MessageRouter.Routes.All(l => subscription.MessageRouter.ContainsCheck(l)));
                shouldCloseConnection = _listeners.OfType<Subscription>().All(r => !r.UserSubscription || r.Status == SubscriptionStatus.Closing || r.Status == SubscriptionStatus.Closed) && !DedicatedRequestConnection.IsDedicatedRequestConnection;
+            }
+            finally
+            {
+                _listenersLock.ExitReadLock();
+            }                

            if (!anyDuplicateSubscription)
            {
                bool needUnsub;
-                lock (_listenersLock)
+                try
+                {
+                    _listenersLock.EnterReadLock();
                    needUnsub = _listeners.Contains(subscription) && !shouldCloseConnection;
+                }
+                finally
+                {
+                    _listenersLock.ExitReadLock();
+                }

                if (needUnsub && _socket.IsOpen)
                    await UnsubscribeAsync(subscription).ConfigureAwait(false);
@@ -926,8 +877,15 @@ namespace CryptoExchange.Net.Sockets.Default
                await CloseAsync().ConfigureAwait(false);
            }

-            lock (_listenersLock)
+            try
+            {
+                _listenersLock.EnterWriteLock();
                _listeners.Remove(subscription);
+            }
+            finally
+            {
+                _listenersLock.ExitWriteLock();
+            }

            subscription.Status = SubscriptionStatus.Closed;
        }
@@ -939,16 +897,9 @@ namespace CryptoExchange.Net.Sockets.Default
        {
            Status = SocketStatus.Disposed;
            periodicEvent?.Set();
-            periodicEvent?.Dispose();
            _socket.Dispose();
        }

-        /// <summary>
-        /// Whether or not a new subscription can be added to this connection
-        /// </summary>
-        /// <returns></returns>
-        public bool CanAddSubscription() => Status == SocketStatus.None || Status == SocketStatus.Connected;
-
        /// <summary>
        /// Add a subscription to this connection
        /// </summary>
@@ -957,9 +908,15 @@ namespace CryptoExchange.Net.Sockets.Default
        {
            if (Status != SocketStatus.None && Status != SocketStatus.Connected)
                return false;
-
-            lock (_listenersLock)
+            try
+            {
+                _listenersLock.EnterWriteLock();
                _listeners.Add(subscription);
+            }
+            finally
+            {
+                _listenersLock.ExitWriteLock();
+            }

            if (subscription.UserSubscription)
                _logger.AddingNewSubscription(SocketId, subscription.Id, UserSubscriptionCount);
@@ -972,8 +929,15 @@ namespace CryptoExchange.Net.Sockets.Default
        /// <param name="id"></param>
        public Subscription? GetSubscription(int id)
        {
-            lock (_listenersLock)
+            try
+            {
+                _listenersLock.EnterReadLock();
                return _listeners.OfType<Subscription>().SingleOrDefault(s => s.Id == id);
+            }
+            finally
+            {
+                _listenersLock.ExitReadLock();
+            }
        }

        /// <summary>
@@ -1021,15 +985,29 @@ namespace CryptoExchange.Net.Sockets.Default

        private async Task SendAndWaitIntAsync(Query query, CancellationToken ct = default)
        {
-            lock (_listenersLock)
+            try
+            {
+                _listenersLock.EnterWriteLock();
                _listeners.Add(query);
+            }
+            finally
+            {
+                _listenersLock.ExitWriteLock();
+            }

            var sendResult = await SendAsync(query.Id, query.Request, query.Weight).ConfigureAwait(false);
            if (!sendResult)
            {
                query.Fail(sendResult.Error!);
-                lock (_listenersLock)
+                try
+                {
+                    _listenersLock.EnterWriteLock();
                    _listeners.Remove(query);
+                }
+                finally
+                {
+                    _listenersLock.ExitWriteLock();
+                }
                return;
            }

@@ -1060,8 +1038,15 @@ namespace CryptoExchange.Net.Sockets.Default
            }
            finally
            {
-                lock (_listenersLock)
+                try
+                {
+                    _listenersLock.EnterWriteLock();
                    _listeners.Remove(query);
+                }
+                finally
+                {
+                    _listenersLock.ExitWriteLock();
+                }
            }
        }

@@ -1084,7 +1069,7 @@ namespace CryptoExchange.Net.Sockets.Default
                    return SendStringAsync(requestId, str, weight);

                str = stringSerializer.Serialize(obj);
-                return SendAsync(requestId, str, weight);
+                return SendStringAsync(requestId, str, weight);
            }

            throw new Exception("Unknown serializer when sending message");
@@ -1168,8 +1153,16 @@ namespace CryptoExchange.Net.Sockets.Default
            if (!DedicatedRequestConnection.IsDedicatedRequestConnection)
            {
                bool anySubscriptions;
-                lock (_listenersLock)
+                try
+                {
+                    _listenersLock.EnterReadLock();
                    anySubscriptions = _listeners.OfType<Subscription>().Any(s => s.UserSubscription);
+                }
+                finally
+                {
+                    _listenersLock.ExitReadLock();
+                }
+
                if (!anySubscriptions)
                {
                    // No need to resubscribe anything
@@ -1180,11 +1173,16 @@ namespace CryptoExchange.Net.Sockets.Default
            }

            bool anyAuthenticated;
-            lock (_listenersLock)
+            try
            {
+                _listenersLock.EnterReadLock();
                anyAuthenticated = _listeners.OfType<Subscription>().Any(s => s.Authenticated)
                    || DedicatedRequestConnection.IsDedicatedRequestConnection && DedicatedRequestConnection.Authenticated;
            }
+            finally
+            {
+                _listenersLock.ExitReadLock();
+            }

            if (anyAuthenticated)
            {
@@ -1209,8 +1207,15 @@ namespace CryptoExchange.Net.Sockets.Default
                    return new CallResult(new WebError("Socket not connected"));

                List<Subscription> subList;
-                lock (_listenersLock)
+                try
+                {
+                    _listenersLock.EnterReadLock();
                    subList = _listeners.OfType<Subscription>().Where(x => x.Active).Skip(batch * batchSize).Take(batchSize).ToList();
+                }
+                finally
+                {
+                    _listenersLock.ExitReadLock();
+                }

                if (subList.Count == 0)
                    break;
@@ -1218,33 +1223,8 @@ namespace CryptoExchange.Net.Sockets.Default
                var taskList = new List<Task<CallResult>>();
                foreach (var subscription in subList)
                {
-                    subscription.ConnectionInvocations = 0;
-                    if (!subscription.Active)
-                        // Can be closed during resubscribing
-                        continue;
-
-                    subscription.Status = SubscriptionStatus.Subscribing;
-                    var result = await ApiClient.RevitalizeRequestAsync(subscription).ConfigureAwait(false);
-                    if (!result)
-                    {
-                        _logger.FailedRequestRevitalization(SocketId, result.Error?.ToString());
-                        subscription.Status = SubscriptionStatus.Pending;
-                        return result;
-                    }
-
-                    var subQuery = subscription.CreateSubscriptionQuery(this);
-                    if (subQuery == null)
-                    {
-                        subscription.Status = SubscriptionStatus.Subscribed;
-                        continue;
-                    }
-                    subQuery.OnComplete = () =>
-                    {
-                        subscription.Status = subQuery.Result!.Success ? SubscriptionStatus.Subscribed : SubscriptionStatus.Pending;
-                        subscription.HandleSubQueryResponse(this, subQuery.Response);
-                    };
-
-                    taskList.Add(SendAndWaitQueryAsync(subQuery));
+                    var subscribeTask = TrySubscribeAsync(subscription, false, default);
+                    taskList.Add(subscribeTask);
                }

                await Task.WhenAll(taskList).ConfigureAwait(false);
@@ -1261,6 +1241,71 @@ namespace CryptoExchange.Net.Sockets.Default
            return CallResult.SuccessResult;
        }

+        /// <summary>
+        /// Try to subscribe a new subscription by sending the subscribe query and wait for the result as needed
+        /// </summary>
+        /// <param name="subscription">The subscription</param>
+        /// <param name="newSubscription">Whether this is a new subscription, or an existing subscription (resubscribing on reconnected socket)</param>
+        /// <param name="subCancelToken">Cancellation token</param>
+        protected internal async Task<CallResult> TrySubscribeAsync(Subscription subscription, bool newSubscription, CancellationToken subCancelToken)
+        {
+            subscription.ConnectionInvocations = 0;
+
+            if (!newSubscription)
+            {
+                if (!subscription.Active)
+                    // Can be closed during resubscribing
+                    return CallResult.SuccessResult;
+
+                var result = await ApiClient.RevitalizeRequestAsync(subscription).ConfigureAwait(false);
+                if (!result)
+                {
+                    _logger.FailedRequestRevitalization(SocketId, result.Error?.ToString());
+                    subscription.Status = SubscriptionStatus.Pending;
+                    return result;
+                }
+            }
+
+            subscription.Status = SubscriptionStatus.Subscribing;
+            var subQuery = subscription.CreateSubscriptionQuery(this);
+            if (subQuery == null)
+            {
+                // No sub query, so successful
+                subscription.Status = SubscriptionStatus.Subscribed;
+                return CallResult.SuccessResult;
+            }
+
+            var subCompleteHandler = () =>
+            {
+                subscription.Status = subQuery.Result!.Success ? SubscriptionStatus.Subscribed : SubscriptionStatus.Pending;
+                subscription.HandleSubQueryResponse(this, subQuery.Response);
+                if (newSubscription && subQuery.Result.Success && subCancelToken != default)
+                {
+                    subscription.CancellationTokenRegistration = subCancelToken.Register(async () =>
+                    {
+                        _logger.CancellationTokenSetClosingSubscription(SocketId, subscription.Id);
+                        await CloseAsync(subscription).ConfigureAwait(false);
+                    }, false);
+                }
+            };
+            subQuery.OnComplete = subCompleteHandler;
+
+            var subQueryResult = await SendAndWaitQueryAsync(subQuery).ConfigureAwait(false);
+            if (!subQueryResult)
+            {
+                _logger.FailedToSubscribe(SocketId, subQueryResult.Error?.ToString());
+                // If this was a server process error or timeout we still send an unsubscribe to prevent messages coming in later
+                if (newSubscription)
+                    await CloseAsync(subscription).ConfigureAwait(false);
+                return new CallResult<UpdateSubscription>(subQueryResult.Error!);
+            }
+
+            if (!subQuery.ExpectsResponse)
+                subCompleteHandler();
+
+            return subQueryResult;
+        }
+
        internal async Task UnsubscribeAsync(Subscription subscription)
        {
            var unsubscribeRequest = subscription.CreateUnsubscriptionQuery(this);
@@ -1268,6 +1313,7 @@ namespace CryptoExchange.Net.Sockets.Default
                return;

            await SendAndWaitQueryAsync(unsubscribeRequest).ConfigureAwait(false);
+            subscription.HandleUnsubQueryResponse(this, unsubscribeRequest.Response);
            _logger.SubscriptionUnsubscribed(SocketId, subscription.Id);
        }

@@ -1281,7 +1327,7 @@ namespace CryptoExchange.Net.Sockets.Default
                return CallResult.SuccessResult;

            var result = await SendAndWaitQueryAsync(subQuery).ConfigureAwait(false);
-            subscription.HandleSubQueryResponse(this, subQuery.Response!);
+            subscription.HandleSubQueryResponse(this, subQuery.Response);
            return result;
        }

@@ -46,7 +46,7 @@ namespace CryptoExchange.Net.Sockets.Default
                    return;

                _status = value;
-                Task.Run(() => StatusChanged?.Invoke(value));
+                StatusChanged?.Invoke(value);
            }
        }

@@ -70,11 +70,6 @@ namespace CryptoExchange.Net.Sockets.Default
        /// </summary>
        public bool Authenticated { get; }

-        /// <summary>
-        /// Matcher for this subscription
-        /// </summary>
-        public MessageMatcher MessageMatcher { get; set; }
-
        /// <summary>
        /// Router for this subscription
        /// </summary>
@@ -154,7 +149,7 @@ namespace CryptoExchange.Net.Sockets.Default
        /// <summary>
        /// Handle an unsubscription query response
        /// </summary>
-        public virtual void HandleUnsubQueryResponse(SocketConnection connection, object message) { }
+        public virtual void HandleUnsubQueryResponse(SocketConnection connection, object? message) { }

        /// <summary>
        /// Create a new unsubscription query
@@ -172,19 +167,6 @@ namespace CryptoExchange.Net.Sockets.Default
        /// <returns></returns>
        protected abstract Query? GetUnsubQuery(SocketConnection connection);

-        /// <inheritdoc />
-        public virtual CallResult<object> Deserialize(IMessageAccessor message, Type type) => message.Deserialize(type);
-
-        /// <summary>
-        /// Handle an update message
-        /// </summary>
-        public CallResult Handle(SocketConnection connection, DateTime receiveTime, string? originalData, object data, MessageHandlerLink matcher)
-        {
-            ConnectionInvocations++;
-            TotalInvocations++;
-            return matcher.Handle(connection, receiveTime, originalData, data);
-        }
-
        /// <summary>
        /// Handle an update message
        /// </summary>
@@ -192,6 +174,14 @@ namespace CryptoExchange.Net.Sockets.Default
        {
            ConnectionInvocations++;
            TotalInvocations++;
+            if (SubscriptionQuery != null && !SubscriptionQuery.Completed && SubscriptionQuery.TimeoutBehavior == TimeoutBehavior.Succeed)
+            {
+                // The subscription query is one where it is successful if there is no error returned
+                // Since we've received a data update for the subscription we can assume the subscribe query was successful
+                // Call timeout to complete 
+                SubscriptionQuery.Timeout();
+            }
+
            return route.Handle(connection, receiveTime, originalData, data);
        }

@@ -224,12 +214,12 @@ namespace CryptoExchange.Net.Sockets.Default
        /// <param name="Id">The id of the subscription</param>
        /// <param name="Status">Subscription status</param>
        /// <param name="Invocations">Number of times this subscription got a message</param>
-        /// <param name="ListenMatcher">Matcher for this subscription</param>
+        /// <param name="MessageRouter">Router for this subscription</param>
        public record SubscriptionState(
            int Id,
            SubscriptionStatus Status,
            int Invocations,
-            MessageMatcher ListenMatcher
+            MessageRouter MessageRouter
        );

        /// <summary>
@@ -238,7 +228,7 @@ namespace CryptoExchange.Net.Sockets.Default
        /// <returns></returns>
        public SubscriptionState GetState()
        {
-            return new SubscriptionState(Id, Status, TotalInvocations, MessageMatcher);
+            return new SubscriptionState(Id, Status, TotalInvocations, MessageRouter);
        }
    }
 }
@@ -233,7 +233,6 @@ namespace CryptoExchange.Net.Sockets.HighPerf
        {
            Status = SocketStatus.Disposed;
            periodicEvent?.Set();
-            periodicEvent?.Dispose();
            _socket.Dispose();
        }

@@ -245,7 +244,9 @@ namespace CryptoExchange.Net.Sockets.HighPerf
        public virtual ValueTask<CallResult> SendAsync<T>(T obj)
        {
            if (_serializer is IByteMessageSerializer byteSerializer)
+            {
                return SendBytesAsync(byteSerializer.Serialize(obj));
+            }
            else if (_serializer is IStringMessageSerializer stringSerializer)
            {
                if (obj is string str)
@@ -15,27 +15,12 @@ namespace CryptoExchange.Net.Sockets.Interfaces
        /// </summary>
        public int Id { get; }
        /// <summary>
-        /// The matcher for this listener
-        /// </summary>
-        public MessageMatcher MessageMatcher { get; }
-        /// <summary>
        /// The message router for this processor
        /// </summary>
        public MessageRouter MessageRouter { get; }
        /// <summary>
        /// Handle a message
        /// </summary>
-        CallResult Handle(SocketConnection connection, DateTime receiveTime, string? originalData, object result, MessageHandlerLink matchedHandler);
-        /// <summary>
-        /// Handle a message
-        /// </summary>
        CallResult? Handle(SocketConnection connection, DateTime receiveTime, string? originalData, object result, MessageRoute route);
-        /// <summary>
-        /// Deserialize a message into object of type
-        /// </summary>
-        /// <param name="accessor"></param>
-        /// <param name="type"></param>
-        /// <returns></returns>
-        CallResult<object> Deserialize(IMessageAccessor accessor, Type type);
    }
 }
@@ -1,185 +0,0 @@
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Sockets.Default;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace CryptoExchange.Net.Sockets
-{
-    /// <summary>
-    /// Message link type
-    /// </summary>
-    public enum MessageLinkType
-    {
-        /// <summary>
-        /// Match when the listen id matches fully to the value
-        /// </summary>
-        Full,
-        /// <summary>
-        /// Match when the listen id starts with the value
-        /// </summary>
-        StartsWith
-    }
-
-    /// <summary>
-    /// Matches a message listen id to a specific listener
-    /// </summary>
-    public class MessageMatcher
-    {
-        /// <summary>
-        /// Linkers in this matcher
-        /// </summary>
-        public MessageHandlerLink[] HandlerLinks { get; }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        private MessageMatcher(params MessageHandlerLink[] links)
-        {
-            HandlerLinks = links;
-        }
-
-        /// <summary>
-        /// Create message matcher
-        /// </summary>
-        public static MessageMatcher Create(string value)
-        {
-            return new MessageMatcher(new MessageHandlerLink<string>(MessageLinkType.Full, value, (con, receiveTime, originalData, msg) => new CallResult<string>(default, null, null)));
-        }
-
-        /// <summary>
-        /// Create message matcher
-        /// </summary>
-        public static MessageMatcher Create<T>(string value)
-        {
-            return new MessageMatcher(new MessageHandlerLink<T>(MessageLinkType.Full, value, (con, receiveTime, originalData, msg) => new CallResult<T>(default, null, null)));
-        }
-
-        /// <summary>
-        /// Create message matcher
-        /// </summary>
-        public static MessageMatcher Create<T>(string value, Func<SocketConnection, DateTime, string?, T, CallResult> handler)
-        {
-            return new MessageMatcher(new MessageHandlerLink<T>(MessageLinkType.Full, value, handler));
-        }
-
-        /// <summary>
-        /// Create message matcher
-        /// </summary>
-        public static MessageMatcher Create<T>(IEnumerable<string> values, Func<SocketConnection, DateTime, string?, T, CallResult> handler)
-        {
-            return new MessageMatcher(values.Select(x => new MessageHandlerLink<T>(MessageLinkType.Full, x, handler)).ToArray());
-        }
-
-        /// <summary>
-        /// Create message matcher
-        /// </summary>
-        public static MessageMatcher Create<T>(MessageLinkType type, string value, Func<SocketConnection, DateTime, string?, T, CallResult> handler)
-        {
-            return new MessageMatcher(new MessageHandlerLink<T>(type, value, handler));
-        }
-
-        /// <summary>
-        /// Create message matcher
-        /// </summary>
-        public static MessageMatcher Create(params MessageHandlerLink[] linkers)
-        {
-            return new MessageMatcher(linkers);
-        }
-
-        /// <summary>
-        /// Whether this matcher contains a specific link
-        /// </summary>
-        public bool ContainsCheck(MessageHandlerLink link) => HandlerLinks.Any(x => x.Type == link.Type && x.Value == link.Value);
-
-        /// <summary>
-        /// Get any handler links matching with the listen id
-        /// </summary>
-        public IEnumerable<MessageHandlerLink> GetHandlerLinks(string listenId) => HandlerLinks.Where(x => x.Check(listenId));
-
-        /// <inheritdoc />
-        public override string ToString() => string.Join(",", HandlerLinks.Select(x => x.ToString()));
-    }
-
-    /// <summary>
-    /// Message handler link
-    /// </summary>
-    public abstract class MessageHandlerLink
-    {
-        /// <summary>
-        /// Type of check
-        /// </summary>
-        public MessageLinkType Type { get; }
-        /// <summary>
-        /// String value of the check
-        /// </summary>
-        public string Value { get; }
-        /// <summary>
-        /// Deserialization type
-        /// </summary>
-        public abstract Type DeserializationType { get; }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public MessageHandlerLink(MessageLinkType type, string value)
-        {
-            Type = type;
-            Value = value;
-        }
-
-        /// <summary>
-        /// Whether this listen id matches this link
-        /// </summary>
-        public bool Check(string listenId)
-        {
-            if (Type == MessageLinkType.Full)
-                return Value.Equals(listenId, StringComparison.Ordinal);
-
-            return listenId.StartsWith(Value, StringComparison.Ordinal);
-        }
-
-        /// <summary>
-        /// Message handler
-        /// </summary>
-        public abstract CallResult Handle(SocketConnection connection, DateTime receiveTime, string? originalData, object data);
-
-        /// <inheritdoc />
-        public override string ToString() => $"{Type} match for \"{Value}\"";
-    }
-
-    /// <summary>
-    /// Message handler link
-    /// </summary>
-    public class MessageHandlerLink<TServer>: MessageHandlerLink
-    {
-        private Func<SocketConnection, DateTime, string?, TServer, CallResult> _handler;
-
-        /// <inheritdoc />
-        public override Type DeserializationType => typeof(TServer);
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public MessageHandlerLink(string value, Func<SocketConnection, DateTime, string?, TServer, CallResult> handler)
-            : this(MessageLinkType.Full, value, handler)
-        {
-        }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public MessageHandlerLink(MessageLinkType type, string value, Func<SocketConnection, DateTime, string?, TServer, CallResult> handler)
-            : base(type, value)
-        {
-            _handler = handler;
-        }
-
-
-        /// <inheritdoc />
-        public override CallResult Handle(SocketConnection connection, DateTime receiveTime, string? originalData, object data)
-        {
-            return _handler(connection, receiveTime, originalData, (TServer)data);
-        }
-    }
-}
@@ -59,11 +59,6 @@ namespace CryptoExchange.Net.Sockets
        /// </summary>
        public object? Response { get; set; }

-        /// <summary>
-        /// Matcher for this query
-        /// </summary>
-        public MessageMatcher MessageMatcher { get; set; }
-
        /// <summary>
        /// Router for this query
        /// </summary>
@@ -132,8 +127,8 @@ namespace CryptoExchange.Net.Sockets
            }
            else
            {
-                Completed = true;
                Result = CallResult.SuccessResult;
+                Completed = true;
                _event.Set();
            }
        }
@@ -146,9 +141,6 @@ namespace CryptoExchange.Net.Sockets
        /// <returns></returns>
        public async Task WaitAsync(TimeSpan timeout, CancellationToken ct) => await _event.WaitAsync(timeout, ct).ConfigureAwait(false);

-        /// <inheritdoc />
-        public virtual CallResult<object> Deserialize(IMessageAccessor message, Type type) => message.Deserialize(type);
-
        /// <summary>
        /// Mark request as timeout
        /// </summary>
@@ -160,11 +152,6 @@ namespace CryptoExchange.Net.Sockets
        /// <param name="error"></param>
        public abstract void Fail(Error error);

-        /// <summary>
-        /// Handle a response message
-        /// </summary>
-        public abstract CallResult Handle(SocketConnection connection, DateTime receiveTime, string? originalData, object message, MessageHandlerLink check);
-
        /// <summary>
        /// Handle a response message
        /// </summary>
@@ -223,47 +210,18 @@ namespace CryptoExchange.Net.Sockets
            return Result ?? CallResult.SuccessResult;
        }

-        /// <inheritdoc />
-        public override CallResult Handle(SocketConnection connection, DateTime receiveTime, string? originalData, object message, MessageHandlerLink check)
-        {
-            if (!PreCheckMessage(connection, message))
-                return CallResult.SuccessResult;
-
-            CurrentResponses++;
-            if (CurrentResponses == RequiredResponses)            
-                Response = message;
-
-            if (Result?.Success != false)
-                // If an error result is already set don't override that
-                Result = check.Handle(connection, receiveTime, originalData, message);
-
-            if (CurrentResponses == RequiredResponses)
-            {
-                Completed = true;
-                _event.Set();
-                OnComplete?.Invoke();
-            }
-
-            return Result;
-        }
-
-        /// <summary>
-        /// Validate if a message is actually processable by this query
-        /// </summary>
-        public virtual bool PreCheckMessage(SocketConnection connection, object message) => true;
-
        /// <inheritdoc />
        public override void Timeout()
        {
            if (Completed)
                return;
                        
-            Completed = true;
            if (TimeoutBehavior == TimeoutBehavior.Fail)
                Result = new CallResult<THandlerResponse>(new TimeoutError());
            else
                Result = new CallResult<THandlerResponse>(default, null, default);

+            Completed = true;
            _event.Set();
            OnComplete?.Invoke();
        }
@@ -276,6 +234,7 @@ namespace CryptoExchange.Net.Sockets

            Result = new CallResult<THandlerResponse>(error);
            Completed = true;
+
            _event.Set();
            OnComplete?.Invoke();
        }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jkorf	73fcb47b17	Updated to version 10.7.0	2026-02-24 11:51:37 +01:00
Jkorf	d41ca3459e	Updated internal lock for subscription to ReaderWriterLockSlim on SocketConnection	2026-02-24 11:32:35 +01:00
Jkorf	bea2b2bd7b	Added Http options to Rest client options	2026-02-24 09:58:48 +01:00
Jan Korf	b29cdc41f3	Shared interfaces pagination update (#274 ) Updated INextPageToken parameter on Shared interfaces to PageRequest type, functionality unchanged Added SupportsAscending and SupportsDescending properties to PaginatedEndpointOptions to expose supported data directions Added MaxAge property to PaginatedEndpointOptions to expose the max age of data that can be requested Added Direction property to Shared interfaces paginated requests to configure pagination data direction Removed PaginationSupport property from PaginatedEndpointOptions, replaced by above new properties Updated Shared GetTradeHistoryRequest EndTime property to be optional Updated I(Futures/Spot)OrderRestClient.GetClosed(Futures/Spot)OrdersOptions from PaginatedEndpointOptions<GetClosedOrdersRequest> to GetClosedOrdersOptions Updated I(Futures/Spot)OrderRestClient.Get(Futures/Spot)UserTradesOptions from PaginatedEndpointOptions<GetUserTradesRequest> to GetUserTradesOptions Updated rate limiting PathStartFilter to ignore added or missing slash before the path Fixed KlineTracker throwing exception if there is no data in the initial snapshot	2026-02-23 14:53:38 +01:00
JKorf	0ce2e778f4	Added check for invalid json in JsonSocketMessageHandler and virtual GetTypeIdentifierNonJson for handling non-json messages	2026-02-22 16:29:05 +01:00
JKorf	36c2411d46	Added parsing of REST response data up to 128 characters for error responses	2026-02-22 16:05:49 +01:00
Jkorf	6d3e72745a	Removed check for OnlyTrackProvidedSymbols and empty initial tracking list	2026-02-17 14:54:57 +01:00
Jkorf	51c74baa26	Updated to version 10.6.2	2026-02-17 14:39:06 +01:00
Jkorf	419e01d009	Fix for websocket queries which don't expects response getting stuck in subscribing state	2026-02-17 14:35:02 +01:00
Jkorf	297eee0e1f	Updated to version 10.6.1	2026-02-16 15:42:33 +01:00
Jkorf	6a9231b1e3	Fixed exception when stopping SymbolOrderBook instance when update is received while closing	2026-02-16 15:39:36 +01:00
Jkorf	e40f2a15b6	Updated to version 10.6.0	2026-02-16 09:38:55 +01:00
Jkorf	b94085a27a	Added some code comments	2026-02-16 09:36:44 +01:00
Jkorf	5e083811df	Added check SymbolOrderBook is still alive when trying to add updates to prevent unnoticed growing in the background when subscription isn't closed while book is	2026-02-16 09:33:39 +01:00
Jkorf	7dcf5cd6ea	Added AddTrackedSymbolsAsync and RemoveTrackedSymbolAsync methods to UserDataTracker, updated minimal fromTime filter in UserDataTracker to 5 seconds	2026-02-16 09:11:01 +01:00
Jkorf	1471a4733f	Updated symbol tracking logic on UserDataTracker, added check for startTime filter for polling being to close to current time	2026-02-13 10:12:43 +01:00
Jkorf	f39d9f7cfb	Updated to version 10.5.4	2026-02-12 11:43:20 +01:00
Jkorf	9fab8faa45	Fixed bug in polling time filter for UserDataTracker items	2026-02-12 11:35:04 +01:00
Jkorf	226f175343	Fixed type check ExchangeParameters GetValue	2026-02-11 14:50:39 +01:00
Jkorf	813bd9f5a1	Updated to version 10.5.3	2026-02-11 13:10:08 +01:00
Jkorf	c8d2b4f09d	Added check EnumConverter to detect undefined int value parsing	2026-02-11 12:57:03 +01:00
Jkorf	6560b82a3e	Fixed orders getting incorrectly set to canceled state for UserDataTracker spot and futures orders	2026-02-11 11:44:32 +01:00
JKorf	e151af8f37	Updated client versions examples	2026-02-10 18:38:45 +01:00
Jkorf	bdf7a07c6f	Updated to version 10.5.2	2026-02-10 16:04:17 +01:00
Jkorf	a8ffe90bf2	Added call to ApiClient.HandleUnhandledMessage when no websocket message processor is found based on topic to allow additional processing	2026-02-10 15:59:35 +01:00
Jkorf	3372b9eb44	Set query completed after setting Result	2026-02-10 15:40:43 +01:00
Jkorf	df25221960	Combined subscribe and re-subscribe logic	2026-02-10 15:40:13 +01:00
Jkorf	7c67a014f5	Added check for subscribe queries with TimeoutBehavior.Success to complete when subscription has received update	2026-02-10 14:31:42 +01:00
Jkorf	65291b3195	Updated to version 10.5.1	2026-02-10 11:53:23 +01:00
Jkorf	ece6a9d27d	Fixed trading mode selection for futures listen key method in FuturesUserDataTracker	2026-02-10 11:51:19 +01:00
Jkorf	1ed29b0474	Updated to version 10.5.0	2026-02-10 10:22:05 +01:00
Jkorf	be2eb01353	Merge branch 'master' of https://github.com/JKorf/CryptoExchange.Net	2026-02-10 10:15:46 +01:00
JKorf	39cd66596d	Added some tests	2026-02-09 21:49:07 +01:00
Jkorf	63f51811a9	Updated logging unmatched websocket message	2026-02-09 16:29:24 +01:00
Jkorf	abda065237	Updated websocket message forwarding logic	2026-02-09 12:57:52 +01:00
Jkorf	759c8b9a58	Fixed bug in UserDataTracker orders logic incorrectly setting order to canceled status	2026-02-09 09:07:17 +01:00
JKorf	8e18482781	Added keep alive for listenkeys to UserDataTracker	2026-02-08 17:02:09 +01:00
Jkorf	87dd2d9d40	Updated to version 10.4.1	2026-02-06 17:19:08 +01:00
Jkorf	f2b0cb2f0d	Updated UserDataTracker to only track symbol when position size > 0, update log verbosity	2026-02-06 17:16:31 +01:00
Jkorf	de0a954a91	Updated to version 10.4.0	2026-02-06 12:00:50 +01:00
Jkorf	4a79ce22ec	Added timeout/ct task cleanup AsyncResetEvent	2026-02-06 11:57:56 +01:00
JKorf	40d480e1fc	Added AutoTimestamp option for socket client, fixed socket client timestamp offset bug	2026-02-05 21:54:16 +01:00
Jan Korf	74e5cf6fc9	Feature/userdata tracker (#271 ) Added user data tracking logic Added LastReceiveTime, SocketStatus and SubscriptionStatus properties to UpdateSubscription Added SharedTransferStatus Enum and property to SharedDeposit Added PositionMode property to SharedPosition model Added IsZero property to SharedQuantity Renamed IWebSocket LastActionTime to LastReceiveTime Updated CryptoExchangeWebsocketClient LastReceiveTime logic Updated Subscription status change event handler to run sync instead of separate task	2026-02-05 16:05:13 +01:00
Jkorf	2fd3912795	Merge branch 'master' of https://github.com/JKorf/CryptoExchange.Net	2026-02-03 08:47:26 +01:00
JKorf	ec44307a0c	Updated AsyncResetEvent implementation	2026-02-02 21:01:35 +01:00
Jkorf	ba55705385	Added Disposed property on BaseClient and IRestClient/ISocketClient interfaces	2026-02-02 09:33:47 +01:00
Jkorf	2c63a83117	Merge branch 'master' of https://github.com/JKorf/CryptoExchange.Net	2026-02-02 08:42:53 +01:00
JKorf	71b1e5e906	Added additional methods for requesting supported symbols to Shared ISpotSymbolRestClient/IFuturesSymbolRestClient interfaces	2026-02-01 15:02:48 +01:00
Jkorf	eaeba6f27e	Made Interval property of Kline tracker public	2026-01-28 10:31:44 +01:00
Jkorf	913bdaa855	Updated to version 10.3.1	2026-01-27 14:01:26 +01:00
Jkorf	5aa5790d0a	Docs	2026-01-23 15:19:33 +01:00
Jkorf	a8321e083e	Fixed potential collection modified exception upon logging message not handled in websocket message handling	2026-01-22 09:57:02 +01:00
Jkorf	ce3fa5f186	Updated to version 10.3.0	2026-01-22 09:33:47 +01:00
Jkorf	fff70a9c65	Updated some testing	2026-01-21 15:38:22 +01:00
Jkorf	cff33bb5ac	Added handling for setting AutoTimestamp in client options when not implemented	2026-01-21 15:37:59 +01:00
Jkorf	21c8133292	Fixed HandleSubQueryResponse not getting called	2026-01-21 11:16:57 +01:00
Jkorf	76772e91ba	Remove legacy websocket message handling	2026-01-21 11:14:06 +01:00
Jkorf	218e0260ce	Added PlatformInfo class for specifying platform information	2026-01-21 10:14:00 +01:00
Jkorf	96b3904266	Fixed state handling for subscriptions where queries do not get a response	2026-01-20 15:19:42 +01:00
Jkorf	bc8faf9822	Updated to version 10.2.5	2026-01-19 10:26:04 +01:00
JKorf	90c1b89ceb	Added GetRestOffsets and GetWebsocketOffsets to TimeOffsetManager	2026-01-18 17:46:42 +01:00
JKorf	21206ffb25	Updated SymbolOrderBook.WaitUntilFirstUpdateBufferedAsync	2026-01-18 17:36:18 +01:00
JKorf	5942423bfb	Updated to version 10.2.4	2026-01-17 16:29:56 +01:00
JKorf	dc4abc42a7	Added WaitUntilFirstUpdateBufferedAsync method on SymbolOrderBook, fixed sequencen validation bug SymbolOrderBook	2026-01-17 16:26:25 +01:00
Jkorf	c71a81e686	Added some util methods, Added CommaSplitStringConverter	2026-01-16 16:39:21 +01:00
Jkorf	550c0eabf1	Updated to version 10.2.3	2026-01-14 08:46:07 +01:00
JKorf	28a2a0c7fd	Fixed semaphore exception when creating a new REST client while time sync is in progress on another client	2026-01-13 22:11:18 +01:00
JKorf	7dd1cd5bbd	Added HandleUnhandledMessage virtual method to SocketApiClient to allow some processing for messages which couldn't be mapped via the normal way	2026-01-13 21:21:30 +01:00