Updated to version 11.2.2

Updated WebSocket message routing improving performance for scenarios with multiple different subscriptions and topics
Added AddCommaSeparated helper for Enum value arrays to ParameterCollection
Improved EnumConverter performance and removed string allocation for happy path
Fixed CreateParamString extension method for ArrayParametersSerialization.Json
Fixed Shared GetOrderBookOptions and GetRecentTradeOptions base validations not being called

.cursor/rules/cryptoexchange-net.mdc

@@ -0,0 +1,71 @@
+---
+description: Conventions for cross-exchange code using CryptoExchange.Net SharedApis abstractions. Apply when generating C# code that interacts with multiple cryptocurrency exchanges through a unified interface.
+globs:
+  - "**/*.cs"
+  - "**/*.csproj"
+alwaysApply: false
+---
+
+# CryptoExchange.Net Conventions
+
+This codebase uses **CryptoExchange.Net** abstractions for multi-exchange access. Each exchange has its own library (Binance.Net, Bybit.Net, OKX.Net, ...). Use `CryptoExchange.Net.SharedApis` for code that should work across exchanges.
+
+## Multi-exchange pattern
+
+```csharp
+using Binance.Net.Clients;
+using OKX.Net.Clients;
+using CryptoExchange.Net.SharedApis;
+
+ISpotTickerRestClient binance = new BinanceRestClient().SpotApi.SharedClient;
+ISpotTickerRestClient okx     = new OKXRestClient().UnifiedApi.SharedClient;
+
+var symbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+
+var ticker = await binance.GetSpotTickerAsync(new GetTickerRequest(symbol));
+// ticker.Data.LastPrice — same model regardless of exchange
+```
+
+## Symbol normalization
+
+`SharedSymbol(TradingMode.Spot, "BTC", "USDT")` is portable. Each library translates to its native format internally. Don't pass raw strings like `"BTCUSDT"` to shared methods.
+
+## Result pattern
+
+Same `WebCallResult<T>` / `CallResult<T>` everywhere. Always check `.Success`. `.Exchange` property identifies which exchange responded — useful for logging.
+
+## Available shared interfaces
+
+- REST tickers/symbols/orderbook/klines/trades, orders (spot/futures, regular/trigger/TP-SL), balances, positions, fees, deposits/withdrawals, transfers
+- WebSocket tickers, book tickers, order book, trades, klines, user data
+
+Each exchange documents which it implements. Not every exchange supports every operation.
+
+## Multi-exchange aggregation
+
+Run requests across exchanges concurrently via `Task.WhenAll` — the library is async-safe and concurrent requests are the norm.
+
+```csharp
+var clients = new ISpotTickerRestClient[] { binance, okx, bybit };
+var tasks   = clients.Select(c => c.GetSpotTickerAsync(new GetTickerRequest(symbol)));
+var results = await Task.WhenAll(tasks);
+```
+
+## Hard rules
+
+- ❌ Never install `CryptoExchange.Net` alone and expect to call exchanges — it's a base library; you need exchange-specific packages
+- ❌ Never mix exchange-specific models in cross-exchange code (use `SharedSymbol`, `SharedSpotTicker`, etc.)
+- ❌ Never use `.Result` / `.Wait()` — async-only
+- ❌ Never iterate sequentially when concurrency is fine — `Task.WhenAll` is your friend
+- ❌ Never instantiate clients per-request — reuse via DI
+- ✅ Always use `.SharedClient` for cross-exchange code
+- ✅ Always check `.Success` before reading `.Data`
+- ✅ Always log with `.Exchange` so multi-exchange logs are decipherable
+- ✅ Always handle "not supported on this exchange" errors gracefully
+
+## Reference
+
+- `AGENTS.md` in repo root has fuller examples
+- `llms.txt` for AI context
+- `Examples/ai-friendly/` for compilable examples
+- For single-exchange code, see that exchange's library (e.g., Binance.Net `AGENTS.md`)

.github/copilot-instructions.md

@@ -0,0 +1,52 @@
+# Copilot Instructions for CryptoExchange.Net
+
+This repository is **CryptoExchange.Net** — the base library powering 28+ cryptocurrency exchange wrappers in C#/.NET (Binance.Net, Bybit.Net, OKX.Net, Kraken.Net, Coinbase.Net, etc.).
+
+When generating code in this ecosystem, follow these conventions:
+
+## You don't install CryptoExchange.Net directly
+
+Install the exchange-specific library you need (`Binance.Net`, `JK.OKX.Net`, `Bybit.Net`, ...) or `CryptoClients.Net` for the bundle. CryptoExchange.Net is pulled in as a dependency.
+
+## Multi-exchange code uses SharedApis
+
+For code that must work against multiple exchanges, use `CryptoExchange.Net.SharedApis` interfaces accessed via `.SharedClient` properties on each exchange's API surface:
+
+```csharp
+using CryptoExchange.Net.SharedApis;
+
+ISpotTickerRestClient binance = new BinanceRestClient().SpotApi.SharedClient;
+ISpotTickerRestClient okx     = new OKXRestClient().UnifiedApi.SharedClient;
+
+var symbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+var ticker = await binance.GetSpotTickerAsync(new GetTickerRequest(symbol));
+```
+
+Same code works on every exchange that implements the interface. Use `Task.WhenAll` for concurrent multi-exchange calls.
+
+## Single-exchange code uses the exchange's own client
+
+For Binance-only code, use `BinanceRestClient` directly (see Binance.Net repo `AGENTS.md`). SharedApis is for portability — use it when you need that.
+
+## Result pattern
+
+Every method returns `WebCallResult<T>` or `CallResult<T>`. Check `.Success` before `.Data`. `.Error` has structured info. `.Exchange` on shared clients identifies which exchange responded.
+
+## Available shared interfaces
+
+REST: tickers, symbols, orderbook, klines, trades, orders (spot/futures, trigger, TP-SL), balances, positions, fees, deposits/withdrawals, transfers.
+WebSocket: tickers, book tickers, orderbook, trades, klines, user data.
+
+Each exchange library implements a subset. Check exchange docs for support matrix.
+
+## Avoid
+
+- Installing `CryptoExchange.Net` alone and trying to call exchange APIs (need exchange-specific packages)
+- Mixing exchange-native models in cross-exchange code (use Shared* types)
+- Synchronous `.Result` / `.Wait()` (use `await`)
+- Instantiating clients per-request (use DI, reuse instances)
+- Sequential per-exchange calls when parallel is fine (`Task.WhenAll`)
+
+## Reference
+
+For detailed patterns see `AGENTS.md` and `llms.txt` in repo root, `examples/ai-friendly/` for compilable examples.

AGENTS.md

@@ -0,0 +1,169 @@
+---
+name: cryptoexchange-net
+description: Use CryptoExchange.Net abstractions when generating C#/.NET code that needs to work across MULTIPLE cryptocurrency exchanges (Binance + Bybit + OKX + Kraken + Coinbase + ...) — for arbitrage, best-execution routing, multi-exchange portfolio dashboards, exchange-agnostic trading bots, or comparison tools. Triggers on requests mentioning multi-exchange, cross-exchange, arbitrage, exchange-agnostic, or unified crypto API in C#. Also triggers when the user is implementing a new exchange library following the CryptoExchange.Net pattern.
+---
+
+# CryptoExchange.Net Skill
+
+## When to use
+
+CryptoExchange.Net is the **base library** powering 28+ exchange-specific libraries (Binance.Net, Bybit.Net, OKX.Net, Kraken.Net, Coinbase.Net, etc.). You don't install it directly — you install the exchange libraries, which depend on it.
+
+**Three usage modes:**
+
+1. **You target ONE exchange** → use that exchange's library directly (e.g., Binance.Net), see its CLAUDE.md.
+2. **You target MULTIPLE exchanges** → install each library you need + use `CryptoExchange.Net.SharedApis` interfaces — write code once, runs against any exchange. **This is the main use case for this skill.**
+3. **You want ALL exchanges in one package** → install `CryptoClients.Net`, get `ExchangeRestClient` and `ExchangeSocketClient` with everything bundled.
+
+## Installation
+
+For a multi-exchange project:
+
+```bash
+dotnet add package Binance.Net
+dotnet add package JK.OKX.Net
+dotnet add package Bybit.Net
+# ... etc
+```
+
+Or the bundle:
+
+```bash
+dotnet add package CryptoClients.Net
+```
+
+## Core Pattern: Shared Interfaces
+
+Every exchange library exposes `.SharedClient` properties on its API surfaces. These implement the same interfaces from `CryptoExchange.Net.SharedApis`.
+
+```csharp
+using Binance.Net.Clients;
+using OKX.Net.Clients;
+using Bybit.Net.Clients;
+using CryptoExchange.Net.SharedApis;
+
+// All three implement ISpotTickerRestClient
+ISpotTickerRestClient binance = new BinanceRestClient().SpotApi.SharedClient;
+ISpotTickerRestClient okx     = new OKXRestClient().UnifiedApi.SharedClient;
+ISpotTickerRestClient bybit   = new BybitRestClient().V5Api.SharedClient;
+
+// Single agnostic call — works against any of them
+var symbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+var ticker = await binance.GetSpotTickerAsync(new GetTickerRequest(symbol));
+// ticker.Data.LastPrice, ticker.Data.HighPrice, etc. — same model regardless of exchange
+```
+
+## Core Pattern: SharedSymbol
+
+Different exchanges format symbols differently — Binance uses `BTCUSDT`, OKX uses `BTC-USDT`, others may have other formats. `SharedSymbol` normalizes this:
+
+```csharp
+var btcusdt = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+// Each exchange library translates SharedSymbol → its native format internally.
+
+// For futures:
+var btcusdtPerp = new SharedSymbol(TradingMode.PerpetualLinear, "BTC", "USDT");
+```
+
+For exchanges that use exotic asset names, see the AssetAliases configuration.
+
+## Available Shared Interfaces
+
+**REST:**
+
+- Market data: `ISpotTickerRestClient`, `IBookTickerRestClient`, `ISpotSymbolRestClient`, `IFuturesSymbolRestClient`, `IOrderBookRestClient`, `IRecentTradeRestClient`, `IKlineRestClient`
+- Orders: `ISpotOrderRestClient`, `IFuturesOrderRestClient`, `ISpotOrderClientIdRestClient`, `IFuturesOrderClientIdRestClient`, `ISpotTriggerOrderRestClient`, `IFuturesTriggerOrderRestClient`, `IFuturesTpSlRestClient`
+- Account: `IBalanceRestClient`, `IPositionRestClient`, `IFeeRestClient`, `ITransferRestClient`, `IDepositRestClient`, `IWithdrawalRestClient`
+
+**WebSocket:**
+
+- `ITickerSocketClient`, `IBookTickerSocketClient`
+- `IOrderBookSocketClient`, `ITradeSocketClient`, `IKlineSocketClient`
+- `IUserTradeSocketClient`, `ISpotOrderSocketClient`, `IFuturesOrderSocketClient`, `IPositionSocketClient`, `IBalanceSocketClient`
+
+Each exchange documents which interfaces it implements (some exchanges don't support every operation).
+
+## Core Pattern: Result Handling
+
+Same as exchange-specific libraries — `WebCallResult<T>` (REST) or `CallResult<T>` (WebSocket) with `.Success`, `.Data`, `.Error`. Always check `.Success` first.
+
+```csharp
+var result = await sharedClient.GetSpotTickerAsync(new GetTickerRequest(symbol));
+if (!result.Success)
+{
+    Console.WriteLine($"[{sharedClient.Exchange}] Error: {result.Error}");
+    return;
+}
+Console.WriteLine($"[{sharedClient.Exchange}] {result.Data.LastPrice}");
+```
+
+`.Exchange` property on every shared client tells you which exchange you're talking to — useful for logging.
+
+## Core Pattern: Multi-Exchange Aggregation
+
+```csharp
+var clients = new ISpotTickerRestClient[]
+{
+    new BinanceRestClient().SpotApi.SharedClient,
+    new OKXRestClient().UnifiedApi.SharedClient,
+    new BybitRestClient().V5Api.SharedClient,
+};
+
+var symbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
+
+// Fetch concurrently from all exchanges
+var tasks = clients.Select(c => c.GetSpotTickerAsync(new GetTickerRequest(symbol))).ToArray();
+var results = await Task.WhenAll(tasks);
+
+for (int i = 0; i < clients.Length; i++)
+{
+    if (results[i].Success)
+        Console.WriteLine($"{clients[i].Exchange}: {results[i].Data!.LastPrice}");
+}
+```
+
+## Per-Exchange Setup
+
+Each exchange library has its own credentials class and options. See each library's CLAUDE.md for specifics. The pattern is consistent: `XxxRestClient(options => { options.ApiCredentials = new XxxCredentials(...); })`.
+
+## Dependency Injection
+
+Each exchange library has its own `services.AddXxx(...)` extension. They all share the same option-builder pattern. Register only the ones you use:
+
+```csharp
+services.AddBinance(restOpts => { /*...*/ }, socketOpts => { /*...*/ });
+services.AddOKX(restOpts => { /*...*/ }, socketOpts => { /*...*/ });
+// Inject IBinanceRestClient, IOKXRestClient, etc.
+```
+
+For one-package access: `services.AddCryptoClients(...)` from `CryptoClients.Net`.
+
+## Common Pitfalls — AVOID
+
+- **Do NOT install `CryptoExchange.Net` and try to call exchange APIs directly** — it's a base abstraction; you need an exchange library.
+- **Do NOT try to use one exchange's models with another's client** — use the SharedApis types (`SharedSymbol`, `SharedSpotTicker`, `SharedSpotOrder`, etc.) for cross-exchange code.
+- **Do NOT block on async operations** — use `await` throughout. `Task.WhenAll` for parallelism across exchanges.
+- **Do NOT assume every exchange supports every operation** — check exchange docs or the library's implementation. Operations may return errors like "not supported on this exchange".
+- **Do NOT instantiate clients per-request** — reuse via DI.
+- **Do NOT iterate exchanges sequentially when concurrency is fine** — use `Task.WhenAll` for ~Nx speedup.
+
+## Implementing a New Exchange Library
+
+If you're building a NEW exchange wrapper following the CryptoExchange.Net pattern (rare but valuable):
+
+- Inherit from `RestApiClient` and `SocketApiClient` base classes
+- Define your own `XxxCredentials` extending `ApiCredentials` (or use `ApiCredentials` directly)
+- Implement `AuthenticationProvider` for the exchange's signing scheme
+- Implement the relevant `Shared*` interfaces on your API client classes for cross-exchange support
+- Follow the same `XxxRestOptions` / `XxxSocketOptions` pattern
+
+See existing libraries (Binance.Net, Bybit.Net) as reference implementations.
+
+## Reference
+
+- Source: https://github.com/JKorf/CryptoExchange.Net
+- Documentation: https://cryptoexchange.jkorf.dev/
+- SharedApis docs: https://cryptoexchange.jkorf.dev/CryptoExchange.Net/idocs_shared.html
+- Bundle (all exchanges): https://github.com/JKorf/CryptoClients.Net
+- Demo app: https://github.com/JKorf/CryptoManager.Net
+- Discord: https://discord.gg/MSpeEtSY8t

CryptoExchange.Net.Protobuf/Converters/Protobuf/ProtobufMessageAccessor.cs

@@ -1,530 +0,0 @@
-using CryptoExchange.Net.Converters.MessageParsing;
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Objects;
-using ProtoBuf;
-using ProtoBuf.Meta;
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Runtime.InteropServices.ComTypes;
-using System.Text;
-using System.Text.Json;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.Converters.Protobuf
-{
-    /// <summary>
-    /// System.Text.Json message accessor
-    /// </summary>
-#if NET5_0_OR_GREATER
-    public abstract class ProtobufMessageAccessor<
-        [DynamicallyAccessedMembers(
-#if NET8_0_OR_GREATER
-        DynamicallyAccessedMemberTypes.NonPublicConstructors |
-        DynamicallyAccessedMemberTypes.PublicFields |
-        DynamicallyAccessedMemberTypes.NonPublicFields |
-        DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
-        DynamicallyAccessedMemberTypes.PublicProperties |
-        DynamicallyAccessedMemberTypes.NonPublicProperties |
-#endif
-        DynamicallyAccessedMemberTypes.PublicNestedTypes |
-        DynamicallyAccessedMemberTypes.NonPublicMethods |
-        DynamicallyAccessedMemberTypes.PublicMethods
-        )]
-    TIntermediateType> : IMessageAccessor
-#else
-    public abstract class ProtobufMessageAccessor<TIntermediateType> : IMessageAccessor
-#endif
-    {
-        /// <summary>
-        /// The intermediate deserialization object
-        /// </summary>
-        protected TIntermediateType? _intermediateType;
-        /// <summary>
-        /// Runtime type model
-        /// </summary>
-        protected RuntimeTypeModel _model;
-
-        /// <inheritdoc />
-        public bool IsValid { get; set; }
-
-        /// <inheritdoc />
-        public abstract bool OriginalDataAvailable { get; }
-
-        /// <inheritdoc />
-        public object? Underlying => _intermediateType;
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public ProtobufMessageAccessor(RuntimeTypeModel model)
-        {
-            _model = model;
-        }
-
-        /// <inheritdoc />
-        public NodeType? GetNodeType()
-        {
-            throw new NotImplementedException();
-        }
-
-        /// <inheritdoc />
-        public NodeType? GetNodeType(MessagePath path)
-        {
-            if (_intermediateType == null)
-                throw new InvalidOperationException("Data not read");
-
-            object? value = _intermediateType;
-            foreach (var step in path)
-            {
-                if (value == null)
-                    break;
-
-                if (step.Type == 0)
-                {
-                    // array index
-                }
-                else if (step.Type == 1)
-                {
-                    // property value
-#pragma warning disable IL2075 // Type is already annotated
-                    value = value.GetType().GetProperty(step.Property!)?.GetValue(value);
-#pragma warning restore
-                }
-                else
-                {
-                    // property name
-                }
-            }
-
-            if (value == null)
-                return null;
-
-            var valueType = value.GetType();
-            if (valueType.IsArray)
-                return NodeType.Array;
-
-            if (IsSimple(valueType))
-                return NodeType.Value;
-
-            return NodeType.Object;
-        }
-
-        private static bool IsSimple(Type type)
-        {
-            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
-            {
-                // nullable type, check if the nested type is simple.
-                return IsSimple(type.GetGenericArguments()[0]);
-            }
-            return type.IsPrimitive
-              || type.IsEnum
-              || type == typeof(string)
-              || type == typeof(decimal);
-        }
-
-
-        /// <inheritdoc />
-#if NET5_0_OR_GREATER
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2075:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-#endif
-        public T? GetValue<T>(MessagePath path)
-        {
-            if (_intermediateType == null)
-                throw new InvalidOperationException("Data not read");
-
-            object? value = _intermediateType;
-            foreach(var step in path)
-            {
-                if (value == null)
-                    break;
-
-                if (step.Type == 0)
-                {
-                    // array index
-                }
-                else if (step.Type == 1)
-                {
-                    // property value
-#pragma warning disable IL2075 // Type is already annotated
-                    value = value.GetType().GetProperty(step.Property!)?.GetValue(value);
-#pragma warning restore
-                }
-                else
-                {
-                    // property name
-                }
-            }
-
-            return (T?)value;
-        }
-
-        /// <inheritdoc />
-        public T?[]? GetValues<T>(MessagePath path)
-        {
-            throw new NotImplementedException();
-        }
-
-        /// <inheritdoc />
-        public abstract string GetOriginalString();
-
-        /// <inheritdoc />
-        public abstract void Clear();
-
-        /// <inheritdoc />
-#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
-        public abstract CallResult<object> Deserialize(
-#if NET5_0_OR_GREATER
-            [DynamicallyAccessedMembers(
-#if NET8_0_OR_GREATER
-            DynamicallyAccessedMemberTypes.NonPublicConstructors |
-            DynamicallyAccessedMemberTypes.PublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
-            DynamicallyAccessedMemberTypes.PublicProperties |
-            DynamicallyAccessedMemberTypes.NonPublicProperties |
-            DynamicallyAccessedMemberTypes.PublicConstructors |
-#endif
-            DynamicallyAccessedMemberTypes.PublicNestedTypes |
-            DynamicallyAccessedMemberTypes.NonPublicMethods |
-            DynamicallyAccessedMemberTypes.PublicMethods
-            )]
-#endif
-        Type type, MessagePath? path = null);
-
-        /// <inheritdoc />
-#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
-        public abstract CallResult<T> Deserialize<
-#if NET5_0_OR_GREATER
-        [DynamicallyAccessedMembers(
-#if NET8_0_OR_GREATER
-            DynamicallyAccessedMemberTypes.NonPublicConstructors |
-            DynamicallyAccessedMemberTypes.PublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
-            DynamicallyAccessedMemberTypes.PublicProperties |
-            DynamicallyAccessedMemberTypes.NonPublicProperties |
-            DynamicallyAccessedMemberTypes.PublicConstructors |
-#endif
-            DynamicallyAccessedMemberTypes.PublicNestedTypes |
-            DynamicallyAccessedMemberTypes.NonPublicMethods |
-            DynamicallyAccessedMemberTypes.PublicMethods
-            )]
-#endif
-        T>(MessagePath? path = null);
-    }
-
-    /// <summary>
-    /// System.Text.Json stream message accessor
-    /// </summary>
-    public class ProtobufStreamMessageAccessor<
-#if NET5_0_OR_GREATER
-            [DynamicallyAccessedMembers(
-#if NET8_0_OR_GREATER
-            DynamicallyAccessedMemberTypes.NonPublicConstructors |
-            DynamicallyAccessedMemberTypes.PublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
-            DynamicallyAccessedMemberTypes.PublicProperties |
-            DynamicallyAccessedMemberTypes.NonPublicProperties |
-            DynamicallyAccessedMemberTypes.PublicConstructors |
-#endif
-            DynamicallyAccessedMemberTypes.PublicNestedTypes |
-            DynamicallyAccessedMemberTypes.NonPublicMethods |
-            DynamicallyAccessedMemberTypes.PublicMethods
-            )]
-#endif
-    TIntermediate> : ProtobufMessageAccessor<TIntermediate>, IStreamMessageAccessor
-    {
-        private Stream? _stream;
-
-        /// <inheritdoc />
-        public override bool OriginalDataAvailable => _stream?.CanSeek == true;
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public ProtobufStreamMessageAccessor(RuntimeTypeModel model) : base(model)
-        {
-        }
-
-        /// <inheritdoc />
-#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
-        public override CallResult<object> Deserialize(
-#if NET5_0_OR_GREATER
-            [DynamicallyAccessedMembers(
-#if NET8_0_OR_GREATER
-            DynamicallyAccessedMemberTypes.NonPublicConstructors |
-            DynamicallyAccessedMemberTypes.PublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
-            DynamicallyAccessedMemberTypes.PublicProperties |
-            DynamicallyAccessedMemberTypes.NonPublicProperties |
-            DynamicallyAccessedMemberTypes.PublicConstructors |
-#endif
-            DynamicallyAccessedMemberTypes.PublicNestedTypes |
-            DynamicallyAccessedMemberTypes.NonPublicMethods |
-            DynamicallyAccessedMemberTypes.PublicMethods
-            )]
-#endif
-        Type type, MessagePath? path = null)
-        {
-            try
-            {
-                var result = _model.Deserialize(type, _stream);
-                return new CallResult<object>(result);
-            }
-            catch (Exception ex)
-            {
-                return new CallResult<object>(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex));
-            }
-        }
-
-        /// <inheritdoc />
-#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
-        public override CallResult<T> Deserialize<            
-#if NET5_0_OR_GREATER
-            [DynamicallyAccessedMembers(
-#if NET8_0_OR_GREATER
-            DynamicallyAccessedMemberTypes.NonPublicConstructors |
-            DynamicallyAccessedMemberTypes.PublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
-            DynamicallyAccessedMemberTypes.PublicProperties |
-            DynamicallyAccessedMemberTypes.NonPublicProperties |
-            DynamicallyAccessedMemberTypes.PublicConstructors |
-#endif
-            DynamicallyAccessedMemberTypes.PublicNestedTypes |
-            DynamicallyAccessedMemberTypes.NonPublicMethods |
-            DynamicallyAccessedMemberTypes.PublicMethods
-            )]
-#endif
-        T>(MessagePath? path = null)
-        {
-            try
-            {
-                var result = _model.Deserialize<T>(_stream);
-                return new CallResult<T>(result);
-            }
-            catch(Exception ex)
-            {
-                return new CallResult<T>(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex));
-            }
-        }
-
-        /// <inheritdoc />
-        public 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
-            {
-                _intermediateType = _model.Deserialize<TIntermediate>(_stream);
-                IsValid = true;
-                return Task.FromResult(CallResult.SuccessResult);
-            }
-            catch (Exception ex)
-            {
-                // Not a json message
-                IsValid = false;
-                return Task.FromResult(new CallResult(new DeserializeError("Protobuf 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;
-            _intermediateType = default;
-        }
-
-    }
-
-    /// <summary>
-    /// Protobuf byte message accessor
-    /// </summary>
-    public class ProtobufByteMessageAccessor<
-#if NET5_0_OR_GREATER
-            [DynamicallyAccessedMembers(
-#if NET8_0_OR_GREATER
-            DynamicallyAccessedMemberTypes.NonPublicConstructors |
-            DynamicallyAccessedMemberTypes.PublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
-            DynamicallyAccessedMemberTypes.PublicProperties |
-            DynamicallyAccessedMemberTypes.NonPublicProperties |
-            DynamicallyAccessedMemberTypes.PublicConstructors |
-#endif
-            DynamicallyAccessedMemberTypes.PublicNestedTypes |
-            DynamicallyAccessedMemberTypes.NonPublicMethods |
-            DynamicallyAccessedMemberTypes.PublicMethods
-            )]
-#endif
-    TIntermediate> : ProtobufMessageAccessor<TIntermediate>, IByteMessageAccessor
-    {
-        private ReadOnlyMemory<byte> _bytes;
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public ProtobufByteMessageAccessor(RuntimeTypeModel model) : base(model)
-        {
-        }
-
-        /// <inheritdoc />
-#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
-        public override CallResult<object> Deserialize(
-
-#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")]
-            [DynamicallyAccessedMembers(
-#if NET8_0_OR_GREATER
-            DynamicallyAccessedMemberTypes.NonPublicConstructors |
-            DynamicallyAccessedMemberTypes.PublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
-            DynamicallyAccessedMemberTypes.PublicProperties |
-            DynamicallyAccessedMemberTypes.NonPublicProperties |
-            DynamicallyAccessedMemberTypes.PublicConstructors |
-#endif
-            DynamicallyAccessedMemberTypes.PublicNestedTypes |
-            DynamicallyAccessedMemberTypes.NonPublicMethods |
-            DynamicallyAccessedMemberTypes.PublicMethods
-            )]
-#endif
-        Type type, MessagePath? path = null)
-        {
-            try
-            {
-                using var stream = new MemoryStream(_bytes.ToArray());
-                stream.Position = 0;
-                var result = _model.Deserialize(type, stream);
-                return new CallResult<object>(result);
-            }
-            catch (Exception ex)
-            {
-                return new CallResult<object>(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex));
-            }
-        }
-
-        /// <inheritdoc />
-#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
-#if NET5_0_OR_GREATER
-        public override CallResult<T> Deserialize<
-            [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2092:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-            [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2095:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-            [DynamicallyAccessedMembers(
-#if NET8_0_OR_GREATER
-            DynamicallyAccessedMemberTypes.NonPublicConstructors |
-            DynamicallyAccessedMemberTypes.PublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
-            DynamicallyAccessedMemberTypes.PublicProperties |
-            DynamicallyAccessedMemberTypes.NonPublicProperties |
-            DynamicallyAccessedMemberTypes.PublicConstructors |
-#endif
-            DynamicallyAccessedMemberTypes.PublicNestedTypes |
-            DynamicallyAccessedMemberTypes.NonPublicMethods |
-            DynamicallyAccessedMemberTypes.PublicMethods
-            )]
-        T>(MessagePath? path = null)
-#else
-        public override CallResult<T> Deserialize<T>(MessagePath? path = null)
-#endif
-        {
-            try
-            {
-                var result = _model.Deserialize<T>(_bytes);
-                return new CallResult<T>(result);
-            }
-            catch (Exception ex)
-            {
-                return new CallResult<T>(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex));
-            }
-        }
-
-        /// <inheritdoc />
-        public CallResult Read(ReadOnlyMemory<byte> data)
-        {
-            _bytes = data;
-
-            try
-            {
-                _intermediateType = _model.Deserialize<TIntermediate>(data);
-                IsValid = true;
-                return CallResult.SuccessResult;
-            }
-            catch (Exception ex)
-            {
-                // Not a json message
-                IsValid = false;
-                return new CallResult(new DeserializeError("Protobuf 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;
-            _intermediateType = default;
-        }
-    }
-}

CryptoExchange.Net.Protobuf/Converters/Protobuf/ProtobufMessageSerializer.cs

@@ -1,53 +0,0 @@
-using CryptoExchange.Net.Interfaces;
-using ProtoBuf.Meta;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Reflection;
-
-namespace CryptoExchange.Net.Converters.Protobuf
-{
-    /// <inheritdoc />
-    public class ProtobufMessageSerializer : IByteMessageSerializer
-    {
-        private RuntimeTypeModel _model;
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public ProtobufMessageSerializer(RuntimeTypeModel model)
-        {
-            _model = model;
-        }
-
-        /// <inheritdoc />
-#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
-#if NET5_0_OR_GREATER
-        public byte[] Serialize<
-            [DynamicallyAccessedMembers(
-#if NET8_0_OR_GREATER
-            DynamicallyAccessedMemberTypes.NonPublicConstructors |
-            DynamicallyAccessedMemberTypes.PublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicFields |
-            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
-            DynamicallyAccessedMemberTypes.PublicProperties |
-            DynamicallyAccessedMemberTypes.NonPublicProperties |
-            DynamicallyAccessedMemberTypes.PublicConstructors |
-#endif
-            DynamicallyAccessedMemberTypes.PublicNestedTypes |
-            DynamicallyAccessedMemberTypes.NonPublicMethods |
-            DynamicallyAccessedMemberTypes.PublicMethods
-            )]
-        T>(T message)
-#else
-        public byte[] Serialize<T>(T message)
-#endif
-        {
-            using var memoryStream = new MemoryStream();
-            _model.Serialize(memoryStream, message);
-            return memoryStream.ToArray();
-        }
-    }
-}

CryptoExchange.Net.Protobuf/CryptoExchange.Net.Protobuf.csproj

@@ -1,47 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;netstandard2.1;net8.0;net9.0;net10.0</TargetFrameworks>
-  </PropertyGroup>
-  <PropertyGroup>
-    <PackageId>CryptoExchange.Net.Protobuf</PackageId>
-    <Authors>JKorf</Authors>
-    <Description>Protobuf support for CryptoExchange.Net</Description>
-    <PackageVersion>10.0.1</PackageVersion>
-    <AssemblyVersion>10.0.1</AssemblyVersion>
-    <FileVersion>10.0.1</FileVersion>
-    <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
-    <PackageTags>CryptoExchange;CryptoExchange.Net</PackageTags>
-    <RepositoryType>git</RepositoryType>
-    <RepositoryUrl>https://github.com/JKorf/CryptoExchange.Net.git</RepositoryUrl>
-    <PackageProjectUrl>https://github.com/JKorf/CryptoExchange.Net/tree/master/CryptoExchange.Net.Protobuf</PackageProjectUrl>
-    <NeutralLanguage>en</NeutralLanguage>
-    <PackageReadmeFile>README.md</PackageReadmeFile>
-    <PackageIcon>icon.png</PackageIcon>
-    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-    <PackageReleaseNotes>https://github.com/JKorf/CryptoExchange.Net?tab=readme-ov-file#release-notes</PackageReleaseNotes>
-    <Nullable>enable</Nullable>
-    <LangVersion>12.0</LangVersion>
-    <PackageLicenseExpression>MIT</PackageLicenseExpression>
-  </PropertyGroup>
-  <ItemGroup>
-    <None Include="..\CryptoExchange.Net\Icon\icon.png" Pack="true" PackagePath="\" />
-    <None Include="README.md" Pack="true" PackagePath="\" />
-  </ItemGroup>
-  <PropertyGroup Label="AOT" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">
-    <IsAotCompatible>true</IsAotCompatible>
-  </PropertyGroup>
-  <PropertyGroup Label="Deterministic Build" Condition="'$(Configuration)' == 'Release'">
-    <PublishRepositoryUrl>true</PublishRepositoryUrl>
-    <IncludeSymbols>true</IncludeSymbols>
-    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
-    <EmbedUntrackedSources>true</EmbedUntrackedSources>
-    <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
-  </PropertyGroup>
-  <PropertyGroup>
-    <DocumentationFile>CryptoExchange.Net.Protobuf.xml</DocumentationFile>
-  </PropertyGroup>
-  <ItemGroup>
-    <PackageReference Include="CryptoExchange.Net" Version="10.0.2" />
-    <PackageReference Include="protobuf-net" Version="3.2.56" />
-  </ItemGroup>
-</Project>

CryptoExchange.Net.Protobuf/CryptoExchange.Net.Protobuf.xml

@@ -1,128 +0,0 @@
-<?xml version="1.0"?>
-<doc>
-    <assembly>
-        <name>CryptoExchange.Net.Protobuf</name>
-    </assembly>
-    <members>
-        <member name="T:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1">
-            <summary>
-            System.Text.Json message accessor
-            </summary>
-        </member>
-        <member name="F:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1._intermediateType">
-            <summary>
-            The intermediate deserialization object
-            </summary>
-        </member>
-        <member name="F:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1._model">
-            <summary>
-            Runtime type model
-            </summary>
-        </member>
-        <member name="P:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.IsValid">
-            <inheritdoc />
-        </member>
-        <member name="P:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.OriginalDataAvailable">
-            <inheritdoc />
-        </member>
-        <member name="P:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.Underlying">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.#ctor(ProtoBuf.Meta.RuntimeTypeModel)">
-            <summary>
-            ctor
-            </summary>
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.GetNodeType">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.GetNodeType(CryptoExchange.Net.Converters.MessageParsing.MessagePath)">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.GetValue``1(CryptoExchange.Net.Converters.MessageParsing.MessagePath)">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.GetValues``1(CryptoExchange.Net.Converters.MessageParsing.MessagePath)">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.GetOriginalString">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.Clear">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.Deserialize(System.Type,System.Nullable{CryptoExchange.Net.Converters.MessageParsing.MessagePath})">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.Deserialize``1(System.Nullable{CryptoExchange.Net.Converters.MessageParsing.MessagePath})">
-            <inheritdoc />
-        </member>
-        <member name="T:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1">
-            <summary>
-            System.Text.Json stream message accessor
-            </summary>
-        </member>
-        <member name="P:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1.OriginalDataAvailable">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1.#ctor(ProtoBuf.Meta.RuntimeTypeModel)">
-            <summary>
-            ctor
-            </summary>
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1.Deserialize(System.Type,System.Nullable{CryptoExchange.Net.Converters.MessageParsing.MessagePath})">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1.Deserialize``1(System.Nullable{CryptoExchange.Net.Converters.MessageParsing.MessagePath})">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1.Read(System.IO.Stream,System.Boolean)">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1.GetOriginalString">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1.Clear">
-            <inheritdoc />
-        </member>
-        <member name="T:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1">
-            <summary>
-            Protobuf byte message accessor
-            </summary>
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1.#ctor(ProtoBuf.Meta.RuntimeTypeModel)">
-            <summary>
-            ctor
-            </summary>
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1.Deserialize(System.Type,System.Nullable{CryptoExchange.Net.Converters.MessageParsing.MessagePath})">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1.Deserialize``1(System.Nullable{CryptoExchange.Net.Converters.MessageParsing.MessagePath})">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1.Read(System.ReadOnlyMemory{System.Byte})">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1.GetOriginalString">
-            <inheritdoc />
-        </member>
-        <member name="P:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1.OriginalDataAvailable">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1.Clear">
-            <inheritdoc />
-        </member>
-        <member name="T:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageSerializer">
-            <inheritdoc />
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageSerializer.#ctor(ProtoBuf.Meta.RuntimeTypeModel)">
-            <summary>
-            ctor
-            </summary>
-        </member>
-        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageSerializer.Serialize``1(``0)">
-            <inheritdoc />
-        </member>
-    </members>
-</doc>

CryptoExchange.Net.Protobuf/README.md

@@ -1,52 +0,0 @@
-# ![.CryptoExchange.Net](https://github.com/JKorf/CryptoExchange.Net/blob/ffcb7db8ff597c2f14982d68464015a748815580/CryptoExchange.Net/Icon/icon.png) CryptoExchange.Net.Proto  
-
-[![.NET](https://img.shields.io/github/actions/workflow/status/JKorf/CryptoExchange.Net/dotnet.yml?style=for-the-badge)](https://github.com/JKorf/CryptoExchange.Net/actions/workflows/dotnet.yml) [![Nuget downloads](https://img.shields.io/nuget/dt/CryptoExchange.Net.Protobuf.svg?style=for-the-badge)](https://www.nuget.org/packages/CryptoExchange.Net.Protobuf) ![License](https://img.shields.io/github/license/JKorf/CryptoExchange.Net?style=for-the-badge)
-
-Protobuf support for CryptoExchange.Net.
-
-## Release notes
-* Version 10.0.1 - 16 Dec 2025
-    * Updated CryptoExchange.Net version to 10.0.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
-
-* Version 10.0.0 - 16 Dec 2025
-    * Updated CryptoExchange.Net version to 10.0.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
-
-* Version 9.13.0 - 10 Nov 2025
-    * Updated CryptoExchange.Net version to 9.13.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
-
-* Version 9.12.0 - 03 Nov 2025
-    * Updated CryptoExchange.Net version to 9.12.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
-
-* Version 9.11.1 - 30 Oct 2025
-    * Updated CryptoExchange.Net version to 9.11.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
-
-* Version 9.11.0 - 30 Oct 2025
-    * Updated CryptoExchange.Net version to 9.11.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
-
-* Version 9.10.0 - 15 Oct 2025
-    * Updated CryptoExchange.Net version to 9.10.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
-
-* Version 9.9.0 - 06 Oct 2025
-    * Updated CryptoExchange.Net version to 9.9.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
-
-* Version 9.8.0 - 30 Sep 2025
-    * Updated CryptoExchange.Net version to 9.8.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
-
-* Version 9.7.0 - 01 Sep 2025
-    * Updated CryptoExchange.Net version to 9.7.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
-
-* Version 9.6.0 - 25 Aug 2025
-    * Updated CryptoExchange.Net version to 9.6.0
-
-* Version 9.5.0 - 19 Aug 2025
-    * Updated CryptoExchange.Net version to 9.5.0
-
-* Version 9.4.0 - 04 Aug 2025
-    * Updated CryptoExchange.Net to version 9.4.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
-    * Updated protobuf-net package version to 3.2.56
-
-* Version 9.3.0 - 23 Jul 2025
-    * Updated CryptoExchange.Net to version 9.3.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
-
-* Version 9.2.0 - 14 Jul 2025
-    * Initial release

CryptoExchange.Net.UnitTests/AsyncResetEventTests.cs

@@ -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
@@ -95,7 +96,7 @@ namespace CryptoExchange.Net.UnitTests
                 waiters.Add(evnt.WaitAsync());
             }
 
-            List<bool> results = null;
+            List<bool>? results = null;
             var resultsWaiter = Task.Run(async () =>
             {
                 await Task.WhenAll(waiters);
@@ -111,7 +112,7 @@ namespace CryptoExchange.Net.UnitTests
 
             await resultsWaiter;
 
-            Assert.That(10 == results.Count(r => r));
+            Assert.That(10 == results?.Count(r => r));
         }
 
         [Test]
@@ -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);
+        }
     }
 }

CryptoExchange.Net.UnitTests/BodySerializationTests.cs

@@ -0,0 +1,43 @@
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using CryptoExchange.Net;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Converters.SystemTextJson;
+
+namespace CryptoExchange.Net.UnitTests
+{
+    internal class BodySerializationTests
+    {
+        [Test]
+        public void ToFormData_SerializesBasicValuesCorrectly()
+        {
+            var parameters = new Dictionary<string, object>()
+            {
+                { "a", "1" },
+                { "b", 2 },
+                { "c", true }
+            };
+
+            var parameterString = parameters.ToFormData();
+
+            Assert.That(parameterString, Is.EqualTo("a=1&b=2&c=True"));
+        }
+
+        [Test]
+        public void JsonSerializer_SerializesBasicValuesCorrectly()
+        {
+            var serializer = new SystemTextJsonMessageSerializer(SerializerOptions.WithConverters(new TestSerializerContext()));
+            var parameters = new Dictionary<string, object>()
+            {
+                { "a", "1" },
+                { "b", 2 },
+                { "c", true }
+            };
+
+            var parameterString = serializer.Serialize(parameters);
+            Assert.That(parameterString, Is.EqualTo("{\"a\":\"1\",\"b\":2,\"c\":true}"));
+        }
+    }
+}

CryptoExchange.Net.UnitTests/CallResultTests.cs

@@ -3,7 +3,6 @@ using CryptoExchange.Net.Objects.Errors;
 using NUnit.Framework;
 using NUnit.Framework.Legacy;
 using System;
-using System.Collections.Generic;
 using System.Net;
 using System.Net.Http;
 
@@ -17,7 +16,7 @@ namespace CryptoExchange.Net.UnitTests
         {
             var result = new CallResult(new ServerError("TestError", ErrorInfo.Unknown));
 
-            ClassicAssert.AreSame(result.Error.ErrorCode, "TestError");
+            ClassicAssert.AreSame(result.Error!.ErrorCode, "TestError");
             ClassicAssert.IsFalse(result);
             ClassicAssert.IsFalse(result.Success);
         }
@@ -37,7 +36,7 @@ namespace CryptoExchange.Net.UnitTests
         {
             var result = new CallResult<object>(new ServerError("TestError", ErrorInfo.Unknown));
 
-            ClassicAssert.AreSame(result.Error.ErrorCode, "TestError");
+            ClassicAssert.AreSame(result.Error!.ErrorCode, "TestError");
             ClassicAssert.IsNull(result.Data);
             ClassicAssert.IsFalse(result);
             ClassicAssert.IsFalse(result.Success);
@@ -74,7 +73,7 @@ namespace CryptoExchange.Net.UnitTests
             var asResult = result.As<TestObject2>(default);
 
             ClassicAssert.IsNotNull(asResult.Error);
-            ClassicAssert.AreSame(asResult.Error.ErrorCode, "TestError");
+            ClassicAssert.AreSame(asResult.Error!.ErrorCode, "TestError");
             ClassicAssert.IsNull(asResult.Data);
             ClassicAssert.IsFalse(asResult);
             ClassicAssert.IsFalse(asResult.Success);
@@ -87,7 +86,7 @@ namespace CryptoExchange.Net.UnitTests
             var asResult = result.AsError<TestObject2>(new ServerError("TestError2", ErrorInfo.Unknown));
 
             ClassicAssert.IsNotNull(asResult.Error);
-            ClassicAssert.AreSame(asResult.Error.ErrorCode, "TestError2");
+            ClassicAssert.AreSame(asResult.Error!.ErrorCode, "TestError2");
             ClassicAssert.IsNull(asResult.Data);
             ClassicAssert.IsFalse(asResult);
             ClassicAssert.IsFalse(asResult.Success);
@@ -100,7 +99,7 @@ namespace CryptoExchange.Net.UnitTests
             var asResult = result.AsError<TestObject2>(new ServerError("TestError2", ErrorInfo.Unknown));
 
             ClassicAssert.IsNotNull(asResult.Error);
-            ClassicAssert.AreSame(asResult.Error.ErrorCode, "TestError2");
+            ClassicAssert.AreSame(asResult.Error!.ErrorCode, "TestError2");
             ClassicAssert.IsNull(asResult.Data);
             ClassicAssert.IsFalse(asResult);
             ClassicAssert.IsFalse(asResult.Success);
@@ -127,7 +126,7 @@ namespace CryptoExchange.Net.UnitTests
             var asResult = result.AsError<TestObject2>(new ServerError("TestError2", ErrorInfo.Unknown));
 
             ClassicAssert.IsNotNull(asResult.Error);
-            Assert.That(asResult.Error.ErrorCode == "TestError2");
+            Assert.That(asResult.Error!.ErrorCode == "TestError2");
             Assert.That(asResult.ResponseStatusCode == System.Net.HttpStatusCode.OK);
             Assert.That(asResult.ResponseTime == TimeSpan.FromSeconds(1));
             Assert.That(asResult.RequestUrl == "https://test.com/api");

CryptoExchange.Net.UnitTests/ClientTests/BaseClientTests.cs

@@ -1,37 +1,22 @@
 using NUnit.Framework;
-using NUnit.Framework.Legacy;
 
-namespace CryptoExchange.Net.UnitTests
+namespace CryptoExchange.Net.UnitTests.ClientTests
 {
     [TestFixture()]
     public class BaseClientTests
     {
-        [TestCase]
-        public void DeserializingValidJson_Should_GiveSuccessfulResult()
-        {
-            // arrange
-            var client = new TestBaseClient();
+        //[TestCase]
+        //public void DeserializingValidJson_Should_GiveSuccessfulResult()
+        //{
+        //    // arrange
+        //    var client = new TestBaseClient();
 
-            // act
-            var result = client.SubClient.Deserialize<object>("{\"testProperty\": 123}");
+        //    // act
+        //    var result = client.SubClient.Deserialize<object>("{\"testProperty\": 123}");
 
-            // assert
-            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);
-        }
+        //    // assert
+        //    Assert.That(result.Success);
+        //}
 
         [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")]

CryptoExchange.Net.UnitTests/ClientTests/RestClientTests.cs

@@ -0,0 +1,151 @@
+using CryptoExchange.Net.Objects;
+using NUnit.Framework;
+using System;
+using System.Net.Http;
+using System.Threading.Tasks;
+using System.Threading;
+using NUnit.Framework.Legacy;
+using CryptoExchange.Net.RateLimiting;
+using CryptoExchange.Net.RateLimiting.Guards;
+using CryptoExchange.Net.RateLimiting.Filters;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using System.Text.Json;
+using CryptoExchange.Net.UnitTests.Implementations;
+using CryptoExchange.Net.Testing;
+
+namespace CryptoExchange.Net.UnitTests.ClientTests
+{
+    [TestFixture()]
+    public class RestClientTests
+    {
+        [TestCase]
+        public async Task RequestingData_Should_ResultInData()
+        {
+            // arrange
+            var client = new TestRestClient();
+            var expected = new TestObject() { DecimalData = 1.23M, IntData = 10, StringData = "Some data" };
+            var strData = JsonSerializer.Serialize(expected, new JsonSerializerOptions { TypeInfoResolver = new TestSerializerContext() });
+            client.ApiClient1.SetNextResponse(strData, System.Net.HttpStatusCode.OK);
+
+            // act
+            var result = await client.ApiClient1.GetResponseAsync<TestObject>();
+
+            // assert
+            Assert.That(result.Success);
+            Assert.That(TestHelpers.AreEqual(expected, result.Data));
+        }
+
+        [TestCase]
+        public async Task ReceivingInvalidData_Should_ResultInError()
+        {
+            // arrange
+            var client = new TestRestClient();
+            client.ApiClient1.SetNextResponse("{\"property\": 123", System.Net.HttpStatusCode.OK);
+
+            // act
+            var result = await client.ApiClient1.GetResponseAsync<TestObject>();
+
+            // assert
+            ClassicAssert.IsFalse(result.Success);
+            Assert.That(result.Error != null);
+        }
+
+        [TestCase]
+        public async Task ReceivingErrorCode_Should_ResultInError()
+        {
+            // arrange
+            var client = new TestRestClient();
+            client.ApiClient1.SetNextResponse("Invalid request", System.Net.HttpStatusCode.BadRequest);
+
+            // act
+            var result = await client.ApiClient1.GetResponseAsync<TestObject>();
+
+            // assert
+            ClassicAssert.IsFalse(result.Success);
+            Assert.That(result.Error != null);
+        }
+
+        [TestCase]
+        public async Task ReceivingErrorAndNotParsingError_Should_ResultInFlatError()
+        {
+            // arrange
+            var client = new TestRestClient();
+            client.ApiClient1.SetNextResponse("{\"errorMessage\": \"Invalid request\", \"errorCode\": 123}", System.Net.HttpStatusCode.BadRequest);
+
+            // act
+            var result = await client.ApiClient1.GetResponseAsync<TestObject>();
+
+            // assert
+            ClassicAssert.IsFalse(result.Success);
+            Assert.That(result.Error != null);
+            Assert.That(result.Error is ServerError);
+        }
+
+        [TestCase]
+        public async Task ReceivingErrorAndNotParsingErrorAndInvalidJson_Should_ContainData()
+        {
+            // arrange
+            var client = new TestRestClient();
+            var response = "<html>...</html>";
+            client.ApiClient1.SetNextResponse(response, System.Net.HttpStatusCode.BadRequest);
+
+            // act
+            var result = await client.ApiClient1.GetResponseAsync<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()
+        {
+            // arrange
+            var client = new TestRestClient();
+            client.ApiClient1.SetNextResponse("{\"errorMessage\": \"Invalid request\", \"errorCode\": 123}", System.Net.HttpStatusCode.BadRequest);
+
+            // act
+            var result = await client.ApiClient1.GetResponseAsync<TestObject>();
+
+            // assert
+            ClassicAssert.IsFalse(result.Success);
+            Assert.That(result.Error != null);
+            Assert.That(result.Error is ServerError);
+            Assert.That(result.Error!.ErrorCode == "123");
+            Assert.That(result.Error.Message == "Invalid request");
+        }
+
+        [TestCase("GET", HttpMethodParameterPosition.InUri)] // No need to test InBody for GET since thats not valid
+        [TestCase("POST", HttpMethodParameterPosition.InBody)]
+        [TestCase("POST", HttpMethodParameterPosition.InUri)]
+        [TestCase("DELETE", HttpMethodParameterPosition.InBody)]
+        [TestCase("DELETE", HttpMethodParameterPosition.InUri)]
+        [TestCase("PUT", HttpMethodParameterPosition.InUri)]
+        [TestCase("PUT", HttpMethodParameterPosition.InBody)]
+        public async Task Setting_Should_ResultInOptionsSet(string method, HttpMethodParameterPosition pos)
+        {
+            // arrange
+            // act
+            var client = new TestRestClient();
+
+            var httpMethod = new HttpMethod(method);
+            client.ApiClient1.SetParameterPosition(httpMethod, pos);
+            client.ApiClient1.SetNextResponse("{}", System.Net.HttpStatusCode.OK);
+
+            var result = await client.ApiClient1.GetResponseAsync<TestObject>(httpMethod, new ParameterCollection
+            {
+                { "TestParam1", "Value1" },
+                { "TestParam2", 2 },
+            });
+
+            // assert
+            Assert.That(result.RequestMethod == new HttpMethod(method));
+            Assert.That(result.RequestBody?.Contains("TestParam1") == true == (pos == HttpMethodParameterPosition.InBody));
+            Assert.That((result.RequestUrl?.ToString().Contains("TestParam1")) == (pos == HttpMethodParameterPosition.InUri));
+            Assert.That(result.RequestBody?.Contains("TestParam2") == true == (pos == HttpMethodParameterPosition.InBody));
+            Assert.That((result.RequestUrl?.ToString().Contains("TestParam2")) == (pos == HttpMethodParameterPosition.InUri));
+        }
+    }
+}

CryptoExchange.Net.UnitTests/ClientTests/SocketClientTests.cs

@@ -0,0 +1,177 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Testing;
+using CryptoExchange.Net.UnitTests.Implementations;
+using NUnit.Framework;
+using System;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.UnitTests.ClientTests
+{
+    [TestFixture]
+    public class SocketClientTests
+    {
+        [TestCase]
+        public void SettingOptions_Should_ResultInOptionsSet()
+        {
+            //arrange
+            //act
+            var client = new TestSocketClient(options =>
+            {
+                options.ExchangeOptions.MaxSocketConnections = 1;
+            });
+
+            //assert
+            Assert.That(1 == client.ApiClient1.ApiOptions.MaxSocketConnections);
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public async Task ConnectSocket_Should_ReturnConnectionResult(bool canConnect)
+        {
+            //arrange
+            var client = new TestSocketClient();
+            var socket = TestHelpers.ConfigureSocketClient(client, "wss://localhost");
+            socket.CanConnect = canConnect;
+
+            //act
+            var connectResult = await client.ApiClient1.SubscribeToUpdatesAsync<TestObject>(x => { }, false, default);
+
+            //assert
+            Assert.That(connectResult.Success == canConnect);
+        }
+
+        [TestCase]
+        public async Task SocketMessages_Should_BeProcessedInDataHandlers()
+        {
+            var client = new TestSocketClient();
+            var socket = TestHelpers.ConfigureSocketClient(client, "wss://localhost");
+
+            var expected = new TestObject() { DecimalData = 1.23M, IntData = 10, StringData = "Some data" };
+            var strData = JsonSerializer.Serialize(expected, new JsonSerializerOptions { TypeInfoResolver = new TestSerializerContext() });
+
+            TestObject? received = null;
+            var resetEvent = new AsyncResetEvent(false);
+
+            await client.ApiClient1.SubscribeToUpdatesAsync<TestObject>(x =>
+            {
+                received = x.Data;
+                resetEvent.Set();
+            }, false, default);
+
+            socket.InvokeMessage(strData);
+            await resetEvent.WaitAsync(TimeSpan.FromSeconds(1));
+
+            Assert.That(received != null);
+        }
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public async Task SocketMessages_Should_ContainOriginalDataIfEnabled(bool enabled)
+        {
+            // arrange
+            var client = new TestSocketClient(options =>
+            {
+                options.ReconnectInterval = TimeSpan.Zero;
+                options.ExchangeOptions.OutputOriginalData = enabled;
+            });
+            var socket = TestHelpers.ConfigureSocketClient(client, "wss://localhost");
+            var expected = new TestObject() { DecimalData = 1.23M, IntData = 10, StringData = "Some data" };
+            var strData = JsonSerializer.Serialize(expected, new JsonSerializerOptions { TypeInfoResolver = new TestSerializerContext() });
+
+            string? originalData = null;
+            var resetEvent = new AsyncResetEvent(false);
+
+            await client.ApiClient1.SubscribeToUpdatesAsync<TestObject>(x =>
+            {
+                originalData = x.OriginalData;
+                resetEvent.Set();
+            }, false, default);
+
+            socket.InvokeMessage(strData);
+            await resetEvent.WaitAsync(TimeSpan.FromSeconds(1));
+
+            // assert
+            Assert.That(originalData == (enabled ? strData : null));
+        }
+
+        [TestCase()]
+        public async Task UnsubscribingStream_Should_CloseTheSocket()
+        {
+            // arrange
+            var client = new TestSocketClient(options =>
+            {
+                options.ReconnectInterval = TimeSpan.Zero;
+            });
+            var socket = TestHelpers.ConfigureSocketClient(client, "wss://localhost");
+
+            var result = await client.ApiClient1.SubscribeToUpdatesAsync<TestObject>(x => {}, false, default);
+
+            // act
+            await client.UnsubscribeAsync(result.Data);
+
+            // assert
+            Assert.That(socket.Connected == false);
+        }
+
+        [TestCase()]
+        public async Task UnsubscribingAll_Should_CloseAllSockets()
+        {
+            // arrange
+            var client = new TestSocketClient(options =>
+            {
+                options.ReconnectInterval = TimeSpan.Zero;
+            });
+            var socket = TestHelpers.ConfigureSocketClient(client, "wss://localhost");
+            var result = await client.ApiClient1.SubscribeToUpdatesAsync<TestObject>(x => { }, false, default);
+
+            var socket2 = TestHelpers.ConfigureSocketClient(client, "wss://localhost");
+            var result2 = await client.ApiClient1.SubscribeToUpdatesAsync<TestObject>(x => { }, false, default);
+
+            // act
+            await client.UnsubscribeAllAsync();
+
+            // assert
+            Assert.That(socket.Connected == false);
+            Assert.That(socket2.Connected == false);
+        }
+
+        [TestCase()]
+        public async Task ErrorResponse_ShouldNot_ConfirmSubscription()
+        {
+            // arrange
+            var client = new TestSocketClient(opt =>
+            {
+                opt.OutputOriginalData = true;
+            });
+
+            var socket = TestHelpers.ConfigureSocketClient(client, "wss://localhost");
+            var subTask = client.ApiClient1.SubscribeToUpdatesAsync<TestObject>(x => { }, true, default);
+
+            socket.InvokeMessage(JsonSerializer.Serialize(new TestSocketMessage { Id = 1, Data = "ErrorWithSub" }));
+
+            var result = await subTask;
+
+            // assert
+            Assert.That(result.Success == false);
+            Assert.That(result.Error!.Message!.Contains("ErrorWithSub"));
+        }
+
+        [TestCase()]
+        public async Task SuccessResponse_Should_ConfirmSubscription()
+        {
+            var client = new TestSocketClient();
+            var socket = TestHelpers.ConfigureSocketClient(client, "wss://localhost");
+            var subTask = client.ApiClient1.SubscribeToUpdatesAsync<TestObject>(x => { }, true, default);
+
+            socket.InvokeMessage(JsonSerializer.Serialize(new TestSocketMessage { Id = 1, Data = "OK" }));
+
+            var result = await subTask;
+
+            var subscription = client.ApiClient1._socketConnections.Single().Value.Subscriptions.Single();
+            Assert.That(subscription.Status == SubscriptionStatus.Subscribed);
+        }
+    }
+}

CryptoExchange.Net.UnitTests/ConverterTests/ArrayConverterTests.cs

@@ -0,0 +1,109 @@
+using CryptoExchange.Net.Attributes;
+using CryptoExchange.Net.Converters;
+using CryptoExchange.Net.Converters.SystemTextJson;
+using NUnit.Framework;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.UnitTests.ConverterTests
+{
+    public class ArrayConverterTests
+    {
+        [Test()]
+        public void TestArrayConverter()
+        {
+            var data = new Test()
+            {
+                Prop1 = 2,
+                Prop2 = null,
+                Prop3 = "123",
+                Prop3Again = "123",
+                Prop4 = null,
+                Prop5 = new Test2
+                {
+                    Prop21 = 3,
+                    Prop22 = "456"
+                },
+                Prop6 = new Test3
+                {
+                    Prop31 = 4,
+                    Prop32 = "789"
+                },
+                Prop7 = TestEnum.Two,
+                TestInternal = new Test
+                {
+                    Prop1 = 10
+                },
+                Prop8 = new Test3
+                {
+                    Prop31 = 5,
+                    Prop32 = "101"
+                },
+            };
+
+            var options = new JsonSerializerOptions()
+            {
+                TypeInfoResolver = new TestSerializerContext()
+            };
+            var serialized = JsonSerializer.Serialize(data);
+            var deserialized = JsonSerializer.Deserialize<Test>(serialized);
+
+            Assert.That(deserialized!.Prop1, Is.EqualTo(2));
+            Assert.That(deserialized.Prop2, Is.Null);
+            Assert.That(deserialized.Prop3, Is.EqualTo("123"));
+            Assert.That(deserialized.Prop3Again, Is.EqualTo("123"));
+            Assert.That(deserialized.Prop4, Is.Null);
+            Assert.That(deserialized.Prop5!.Prop21, Is.EqualTo(3));
+            Assert.That(deserialized.Prop5!.Prop22, Is.EqualTo("456"));
+            Assert.That(deserialized.Prop6!.Prop31, Is.EqualTo(4));
+            Assert.That(deserialized.Prop6.Prop32, Is.EqualTo("789"));
+            Assert.That(deserialized.Prop7, Is.EqualTo(TestEnum.Two));
+            Assert.That(deserialized.TestInternal!.Prop1, Is.EqualTo(10));
+            Assert.That(deserialized.Prop8!.Prop31, Is.EqualTo(5));
+            Assert.That(deserialized.Prop8.Prop32, Is.EqualTo("101"));
+        }
+    }
+
+    [JsonConverter(typeof(ArrayConverter<Test>))]
+    public record Test
+    {
+        [ArrayProperty(0)]
+        public int Prop1 { get; set; }
+        [ArrayProperty(1)]
+        public int? Prop2 { get; set; }
+        [ArrayProperty(2)]
+        public string? Prop3 { get; set; }
+        [ArrayProperty(2)]
+        public string? Prop3Again { get; set; }
+        [ArrayProperty(3)]
+        public string? Prop4 { get; set; }
+        [ArrayProperty(4)]
+        public Test2? Prop5 { get; set; }
+        [ArrayProperty(5)]
+        public Test3? Prop6 { get; set; }
+        [ArrayProperty(6), JsonConverter(typeof(EnumConverter<TestEnum>))]
+        public TestEnum? Prop7 { get; set; }
+        [ArrayProperty(7)]
+        public Test? TestInternal { get; set; }
+        [ArrayProperty(8), JsonConversion]
+        public Test3? Prop8 { get; set; }
+    }
+
+    [JsonConverter(typeof(ArrayConverter<Test2>))]
+    public record Test2
+    {
+        [ArrayProperty(0)]
+        public int Prop21 { get; set; }
+        [ArrayProperty(1)]
+        public string? Prop22 { get; set; }
+    }
+
+    public record Test3
+    {
+        [JsonPropertyName("prop31")]
+        public int Prop31 { get; set; }
+        [JsonPropertyName("prop32")]
+        public string? Prop32 { get; set; }
+    }
+
+}

CryptoExchange.Net.UnitTests/ConverterTests/BoolConverterTests.cs

@@ -0,0 +1,57 @@
+using CryptoExchange.Net.Converters.SystemTextJson;
+using NUnit.Framework;
+using System.Text.Json;
+
+namespace CryptoExchange.Net.UnitTests.ConverterTests
+{
+    public class BoolConverterTests
+    {
+        [TestCase("1", true)]
+        [TestCase("true", true)]
+        [TestCase("yes", true)]
+        [TestCase("y", true)]
+        [TestCase("on", true)]
+        [TestCase("-1", false)]
+        [TestCase("0", false)]
+        [TestCase("n", false)]
+        [TestCase("no", false)]
+        [TestCase("false", false)]
+        [TestCase("off", false)]
+        [TestCase("", null)]
+        public void TestBoolConverter(string value, bool? expected)
+        {
+            var val = value == null ? "null" : $"\"{value}\"";
+            var output = JsonSerializer.Deserialize<STJBoolObject>($"{{ \"Value\": {val} }}", SerializerOptions.WithConverters(new TestSerializerContext()));
+            Assert.That(output!.Value == expected);
+        }
+
+        [TestCase("1", true)]
+        [TestCase("true", true)]
+        [TestCase("yes", true)]
+        [TestCase("y", true)]
+        [TestCase("on", true)]
+        [TestCase("-1", false)]
+        [TestCase("0", false)]
+        [TestCase("n", false)]
+        [TestCase("no", false)]
+        [TestCase("false", false)]
+        [TestCase("off", false)]
+        [TestCase("", false)]
+        public void TestBoolConverterNotNullable(string value, bool expected)
+        {
+            var val = value == null ? "null" : $"\"{value}\"";
+            var output = JsonSerializer.Deserialize<NotNullableSTJBoolObject>($"{{ \"Value\": {val} }}", SerializerOptions.WithConverters(new TestSerializerContext()));
+            Assert.That(output!.Value == expected);
+        }
+    }
+
+    public class STJBoolObject
+    {
+        public bool? Value { get; set; }
+    }
+
+    public class NotNullableSTJBoolObject
+    {
+        public bool Value { get; set; }
+    }
+}

CryptoExchange.Net.UnitTests/ConverterTests/DateTimeConverterTests.cs

@@ -0,0 +1,119 @@
+using CryptoExchange.Net.Converters.SystemTextJson;
+using NUnit.Framework;
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.UnitTests.ConverterTests
+{
+    public class DateTimeConverterTests
+    {
+        [TestCase("2021-05-12")]
+        [TestCase("20210512")]
+        [TestCase("210512")]
+        [TestCase("1620777600.000")]
+        [TestCase("1620777600000")]
+        [TestCase("2021-05-12T00:00:00.000Z")]
+        [TestCase("2021-05-12T00:00:00.000000000Z")]
+        [TestCase("0.000000", true)]
+        [TestCase("0", true)]
+        [TestCase("", true)]
+        [TestCase("  ", true)]
+        public void TestDateTimeConverterString(string input, bool expectNull = false)
+        {
+            var output = JsonSerializer.Deserialize<STJTimeObject>($"{{ \"time\": \"{input}\" }}");
+            Assert.That(output!.Time == (expectNull ? null : new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc)));
+        }
+
+        [TestCase(1620777600.000)]
+        [TestCase(1620777600000d)]
+        public void TestDateTimeConverterDouble(double input)
+        {
+            var output = JsonSerializer.Deserialize<STJTimeObject>($"{{ \"time\": {input} }}");
+            Assert.That(output!.Time == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [TestCase(1620777600)]
+        [TestCase(1620777600000)]
+        [TestCase(1620777600000000)]
+        [TestCase(1620777600000000000)]
+        [TestCase(0, true)]
+        public void TestDateTimeConverterLong(long input, bool expectNull = false)
+        {
+            var output = JsonSerializer.Deserialize<STJTimeObject>($"{{ \"time\": {input} }}");
+            Assert.That(output!.Time == (expectNull ? null : new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc)));
+        }
+
+        [TestCase(1620777600)]
+        [TestCase(1620777600.000)]
+        public void TestDateTimeConverterFromSeconds(double input)
+        {
+            var output = DateTimeConverter.ConvertFromSeconds(input);
+            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToSeconds()
+        {
+            var output = DateTimeConverter.ConvertToSeconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(output == 1620777600);
+        }
+
+        [TestCase(1620777600000)]
+        [TestCase(1620777600000.000)]
+        public void TestDateTimeConverterFromMilliseconds(double input)
+        {
+            var output = DateTimeConverter.ConvertFromMilliseconds(input);
+            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToMilliseconds()
+        {
+            var output = DateTimeConverter.ConvertToMilliseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(output == 1620777600000);
+        }
+
+        [TestCase(1620777600000000)]
+        public void TestDateTimeConverterFromMicroseconds(long input)
+        {
+            var output = DateTimeConverter.ConvertFromMicroseconds(input);
+            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToMicroseconds()
+        {
+            var output = DateTimeConverter.ConvertToMicroseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(output == 1620777600000000);
+        }
+
+        [TestCase(1620777600000000000)]
+        public void TestDateTimeConverterFromNanoseconds(long input)
+        {
+            var output = DateTimeConverter.ConvertFromNanoseconds(input);
+            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToNanoseconds()
+        {
+            var output = DateTimeConverter.ConvertToNanoseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(output == 1620777600000000000);
+        }
+
+        [TestCase()]
+        public void TestDateTimeConverterNull()
+        {
+            var output = JsonSerializer.Deserialize<STJTimeObject>($"{{ \"time\": null }}");
+            Assert.That(output!.Time == null);
+        }
+    }
+
+    public class STJTimeObject
+    {
+        [JsonConverter(typeof(DateTimeConverter))]
+        [JsonPropertyName("time")]
+        public DateTime? Time { get; set; }
+    }
+}

CryptoExchange.Net.UnitTests/ConverterTests/DecimalConverterTests.cs

@@ -0,0 +1,49 @@
+using CryptoExchange.Net.Converters.SystemTextJson;
+using NUnit.Framework;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.UnitTests.ConverterTests
+{
+    public class DecimalConverterTests
+    {
+        [TestCase("1", 1)]
+        [TestCase("1.1", 1.1)]
+        [TestCase("-1.1", -1.1)]
+        [TestCase(null, null)]
+        [TestCase("", null)]
+        [TestCase("null", null)]
+        [TestCase("nan", null)]
+        [TestCase("1E+2", 100)]
+        [TestCase("1E-2", 0.01)]
+        [TestCase("Infinity", 999)] // 999 is workaround for not being able to specify decimal.MinValue
+        [TestCase("-Infinity", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
+        [TestCase("80228162514264337593543950335", 999)] // 999 is workaround for not being able to specify decimal.MaxValue
+        [TestCase("-80228162514264337593543950335", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
+        public void TestDecimalConverterString(string value, decimal? expected)
+        {
+            var result = JsonSerializer.Deserialize<STJDecimalObject>("{ \"test\": \"" + value + "\"}");
+            Assert.That(result!.Test, Is.EqualTo(expected == -999 ? decimal.MinValue : expected == 999 ? decimal.MaxValue : expected));
+        }
+
+        [TestCase("1", 1)]
+        [TestCase("1.1", 1.1)]
+        [TestCase("-1.1", -1.1)]
+        [TestCase("null", null)]
+        [TestCase("1E+2", 100)]
+        [TestCase("1E-2", 0.01)]
+        [TestCase("80228162514264337593543950335", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
+        public void TestDecimalConverterNumber(string value, decimal? expected)
+        {
+            var result = JsonSerializer.Deserialize<STJDecimalObject>("{ \"test\": " + value + "}");
+            Assert.That(result!.Test, Is.EqualTo(expected == -999 ? decimal.MaxValue : expected));
+        }
+    }
+
+    public class STJDecimalObject
+    {
+        [JsonConverter(typeof(DecimalConverter))]
+        [JsonPropertyName("test")]
+        public decimal? Test { get; set; }
+    }
+}

CryptoExchange.Net.UnitTests/ConverterTests/EnumConverterTests.cs

@@ -0,0 +1,147 @@
+using CryptoExchange.Net.Attributes;
+using CryptoExchange.Net.Converters.SystemTextJson;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Testing;
+using NUnit.Framework;
+using System;
+using System.Diagnostics;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.UnitTests.ConverterTests
+{
+    public class EnumConverterTests
+    {
+        [TestCase(TestEnum.One, "1")]
+        [TestCase(TestEnum.Two, "2")]
+        [TestCase(TestEnum.Three, "three")]
+        [TestCase(TestEnum.Four, "Four")]
+        [TestCase(null, null)]
+        public void TestEnumConverterNullableGetStringTests(TestEnum? value, string expected)
+        {
+            var output = EnumConverter.GetString(value);
+            Assert.That(output == expected);
+        }
+
+        [TestCase(TestEnum.One, "1")]
+        [TestCase(TestEnum.Two, "2")]
+        [TestCase(TestEnum.Three, "three")]
+        [TestCase(TestEnum.Four, "Four")]
+        public void TestEnumConverterGetStringTests(TestEnum value, string expected)
+        {
+            var output = EnumConverter.GetString(value);
+            Assert.That(output == expected);
+        }
+
+        [TestCase("1", TestEnum.One)]
+        [TestCase("2", TestEnum.Two)]
+        [TestCase("3", TestEnum.Three)]
+        [TestCase("three", TestEnum.Three)]
+        [TestCase("Four", TestEnum.Four)]
+        [TestCase("four", TestEnum.Four)]
+        [TestCase("Four1", null)]
+        [TestCase(null, null)]
+        public void TestEnumConverterNullableDeserializeTests(string value, TestEnum? expected)
+        {
+            var val = value == null ? "null" : $"\"{value}\"";
+            var output = JsonSerializer.Deserialize<STJEnumObject>($"{{ \"Value\": {val} }}", SerializerOptions.WithConverters(new TestSerializerContext()));
+            Assert.That(output!.Value == expected);
+        }
+
+        [TestCase("1", TestEnum.One)]
+        [TestCase("2", TestEnum.Two)]
+        [TestCase("3", TestEnum.Three)]
+        [TestCase("three", TestEnum.Three)]
+        [TestCase("Four", TestEnum.Four)]
+        [TestCase("four", TestEnum.Four)]
+        [TestCase("Four1", (TestEnum)(-9))]
+        [TestCase(null, (TestEnum)(-9))]
+        public void TestEnumConverterNotNullableDeserializeTests(string value, TestEnum expected)
+        {
+            var val = value == null ? "null" : $"\"{value}\"";
+            var output = JsonSerializer.Deserialize<NotNullableSTJEnumObject>($"{{ \"Value\": {val} }}");
+            Assert.That(output!.Value == expected);
+        }
+
+        [Test]
+        public void TestEnumConverterMapsUndefinedValueCorrectlyIfDefaultIsDefined()
+        {
+            var output = JsonSerializer.Deserialize<TestEnum2>($"\"TestUndefined\"");
+            Assert.That((int)output == -99);
+        }
+
+        [TestCase("1", TestEnum.One)]
+        [TestCase("2", TestEnum.Two)]
+        [TestCase("3", TestEnum.Three)]
+        [TestCase("three", TestEnum.Three)]
+        [TestCase("Four", TestEnum.Four)]
+        [TestCase("four", TestEnum.Four)]
+        [TestCase("Four1", null)]
+        [TestCase(null, null)]
+        public void TestEnumConverterParseStringTests(string value, TestEnum? expected)
+        {
+            var result = EnumConverter.ParseString<TestEnum>(value);
+            Assert.That(result == expected);
+        }
+
+        [Test]
+        public void TestEnumConverterParseNullOnNonNullableOnlyLogsOnce()
+        {
+            LibraryHelpers.StaticLogger = new TraceLogger();
+            var listener = new EnumValueTraceListener();
+            Trace.Listeners.Add(listener);
+            EnumConverter<TestEnum>.Reset();
+            try
+            {
+                Assert.Throws<Exception>(() =>
+                {
+                    var result = JsonSerializer.Deserialize<NotNullableSTJEnumObject>("{\"Value\": null}", SerializerOptions.WithConverters(new TestSerializerContext()));
+                });
+
+                Assert.DoesNotThrow(() =>
+                {
+                    var result2 = JsonSerializer.Deserialize<NotNullableSTJEnumObject>("{\"Value\": null}", SerializerOptions.WithConverters(new TestSerializerContext()));
+                });
+            }
+            finally
+            {
+                Trace.Listeners.Remove(listener);
+            }
+        }
+    }
+    public class STJEnumObject
+    {
+        public TestEnum? Value { get; set; }
+    }
+
+    public class NotNullableSTJEnumObject
+    {
+        public TestEnum Value { get; set; }
+    }
+
+    [JsonConverter(typeof(EnumConverter<TestEnum>))]
+    public enum TestEnum
+    {
+        [Map("1")]
+        One,
+        [Map("2")]
+        Two,
+        [Map("three", "3")]
+        Three,
+        Four
+    }
+
+    [JsonConverter(typeof(EnumConverter<TestEnum2>))]
+    public enum TestEnum2
+    {
+        [Map("-9")]
+        Minus9 = -9,
+        [Map("1")]
+        One,
+        [Map("2")]
+        Two,
+        [Map("three", "3")]
+        Three,
+        Four
+    }
+}

CryptoExchange.Net.UnitTests/ConverterTests/SharedModelConversionTests.cs

@@ -0,0 +1,46 @@
+using CryptoExchange.Net.Converters.SystemTextJson;
+using CryptoExchange.Net.SharedApis;
+using NUnit.Framework;
+using System;
+using System.Text.Json;
+
+namespace CryptoExchange.Net.UnitTests.ConverterTests
+{
+    [TestFixture()]
+    public class SharedModelConversionTests
+    {
+        [TestCase(TradingMode.Spot, "ETH", "USDT", null)]
+        [TestCase(TradingMode.PerpetualLinear, "ETH", "USDT", null)]
+        [TestCase(TradingMode.DeliveryLinear, "ETH", "USDT", 1748432430)]
+        public void TestSharedSymbolConversion(TradingMode tradingMode, string baseAsset, string quoteAsset, int? deliverTime)
+        {
+            DateTime? time = deliverTime == null ? null : DateTimeConverter.ParseFromDouble(deliverTime.Value);
+            var symbol = new SharedSymbol(tradingMode, baseAsset, quoteAsset, time);
+
+            var serialized = JsonSerializer.Serialize(symbol);
+            var restored = JsonSerializer.Deserialize<SharedSymbol>(serialized);
+
+            Assert.That(restored!.TradingMode, Is.EqualTo(symbol.TradingMode));
+            Assert.That(restored.BaseAsset, Is.EqualTo(symbol.BaseAsset));
+            Assert.That(restored.QuoteAsset, Is.EqualTo(symbol.QuoteAsset));
+            Assert.That(restored.DeliverTime, Is.EqualTo(symbol.DeliverTime));
+        }
+
+        [TestCase(0.1, null, null)]
+        [TestCase(0.1, 0.1, null)]
+        [TestCase(0.1, 0.1, 0.1)]
+        [TestCase(null, 0.1, null)]
+        [TestCase(null, 0.1, 0.1)]
+        public void TestSharedQuantityConversion(double? baseQuantity, double? quoteQuantity, double? contractQuantity)
+        {
+            var symbol = new SharedOrderQuantity((decimal?)baseQuantity, (decimal?)quoteQuantity, (decimal?)contractQuantity);
+
+            var serialized = JsonSerializer.Serialize(symbol);
+            var restored = JsonSerializer.Deserialize<SharedOrderQuantity>(serialized);
+
+            Assert.That(restored!.QuantityInBaseAsset, Is.EqualTo(symbol.QuantityInBaseAsset));
+            Assert.That(restored.QuantityInQuoteAsset, Is.EqualTo(symbol.QuantityInQuoteAsset));
+            Assert.That(restored.QuantityInContracts, Is.EqualTo(symbol.QuantityInContracts));
+        }
+    }
+}

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

@@ -3,6 +3,7 @@
   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
     <IsPackable>false</IsPackable>
+	  <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <ItemGroup>

CryptoExchange.Net.UnitTests/ExchangeSymbolCacheTests.cs

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

CryptoExchange.Net.UnitTests/Implementations/TestAuthenticationProvider.cs

@@ -0,0 +1,20 @@
+using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Clients;
+using CryptoExchange.Net.Objects;
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.UnitTests.Implementations
+{
+    internal class TestAuthenticationProvider : AuthenticationProvider<TestCredentials, TestCredentials>
+    {
+        public TestAuthenticationProvider(TestCredentials credentials) : base(credentials, credentials)
+        {
+        }
+
+        public override void ProcessRequest(RestApiClient apiClient, RestRequestConfiguration requestConfig)
+        {
+            requestConfig.Headers ??= new Dictionary<string, string>();
+            requestConfig.Headers["Authorization"] = Credential.Key;
+        }
+    }
+}

CryptoExchange.Net.UnitTests/Implementations/TestCredentials.cs

@@ -0,0 +1,30 @@
+using CryptoExchange.Net.Authentication;
+using System;
+
+namespace CryptoExchange.Net.UnitTests.Implementations
+{
+    internal class TestCredentials : HMACCredential
+    {
+        public TestCredentials() { }
+
+        public TestCredentials(string key, string secret) : base(key, secret)
+        {
+        }
+
+        public TestCredentials(HMACCredential credential) : base(credential.Key, credential.Secret)
+        {
+        }
+
+        public TestCredentials WithHMAC(string key, string secret)
+        {
+            if (!string.IsNullOrEmpty(Key)) throw new InvalidOperationException("Credentials already set");
+
+            Key = key;
+            Secret = secret;
+            return this;
+        }
+
+        /// <inheritdoc />
+        public override ApiCredentials Copy() => new TestCredentials(this);
+    }
+}

CryptoExchange.Net.UnitTests/Implementations/TestEnvironment.cs

@@ -0,0 +1,64 @@
+using CryptoExchange.Net.Objects;
+
+namespace CryptoExchange.Net.UnitTests.Implementations
+{
+    internal class TestEnvironment : TradeEnvironment
+    {
+        public string RestClientAddress { get; }
+        public string SocketClientAddress { get; }
+
+        internal TestEnvironment(
+            string name,
+            string restAddress,
+            string streamAddress) :
+            base(name)
+        {
+            RestClientAddress = restAddress;
+            SocketClientAddress = streamAddress;
+        }
+
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
+        public TestEnvironment() : base(TradeEnvironmentNames.Live)
+#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
+        { }
+
+        /// <summary>
+        /// Get the environment by name
+        /// </summary>
+        public static TestEnvironment? GetEnvironmentByName(string? name)
+         => name switch
+         {
+             TradeEnvironmentNames.Live => Live,
+             "" => Live,
+             null => Live,
+             _ => default
+         };
+
+        /// <summary>
+        /// Available environment names
+        /// </summary>
+        /// <returns></returns>
+        public static string[] All => [Live.Name];
+
+        /// <summary>
+        /// Live environment
+        /// </summary>
+        public static TestEnvironment Live { get; }
+            = new TestEnvironment(TradeEnvironmentNames.Live,
+                                     "https://localhost",
+                                     "wss://localhost");
+
+        /// <summary>
+        /// Create a custom environment
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="spotRestAddress"></param>
+        /// <param name="spotSocketStreamsAddress"></param>
+        /// <returns></returns>
+        public static TestEnvironment CreateCustom(
+                        string name,
+                        string spotRestAddress,
+                        string spotSocketStreamsAddress)
+            => new TestEnvironment(name, spotRestAddress, spotSocketStreamsAddress);
+    }
+}

CryptoExchange.Net.UnitTests/Implementations/TestObject.cs

@@ -1,11 +1,11 @@
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.UnitTests.TestImplementations
+namespace CryptoExchange.Net.UnitTests.Implementations
 {
     public class TestObject
     {
         [JsonPropertyName("other")]
-        public string StringData { get; set; }
+        public string StringData { get; set; } = string.Empty;
         [JsonPropertyName("intData")]
         public int IntData { get; set; }
         [JsonPropertyName("decimalData")]

CryptoExchange.Net.UnitTests/Implementations/TestQuery.cs

@@ -0,0 +1,25 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
+using CryptoExchange.Net.Sockets;
+using CryptoExchange.Net.Sockets.Default;
+using CryptoExchange.Net.Sockets.Default.Routing;
+using System;
+
+namespace CryptoExchange.Net.UnitTests.Implementations
+{
+    internal class TestQuery : Query<TestSocketMessage>
+    {
+        public TestQuery(TestSocketMessage request, bool authenticated) : base(request, authenticated, 1)
+        {
+            MessageRouter = MessageRouter.CreateWithoutTopicFilter<TestSocketMessage>(request.Id.ToString(), HandleMessage);
+        }
+
+        private CallResult? HandleMessage(SocketConnection connection, DateTime time, string? arg3, TestSocketMessage message)
+        {
+            if (message.Data != "OK")
+                return new CallResult(new ServerError(ErrorInfo.Unknown with { Message = message.Data }));
+
+            return CallResult.SuccessResult;
+        }
+    }
+}

CryptoExchange.Net.UnitTests/Implementations/TestRestApiClient.cs

@@ -0,0 +1,66 @@
+using CryptoExchange.Net.Clients;
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
+using CryptoExchange.Net.Converters.SystemTextJson;
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.RateLimiting;
+using CryptoExchange.Net.SharedApis;
+using CryptoExchange.Net.Testing.Implementations;
+using Microsoft.Extensions.Logging;
+using System;
+using System.IO;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.UnitTests.Implementations
+{
+    internal class TestRestApiClient : RestApiClient<TestEnvironment, TestAuthenticationProvider, TestCredentials>
+    {
+        protected override IRestMessageHandler MessageHandler { get; } = new TestRestMessageHandler();
+
+        public TestRestApiClient(ILogger logger, HttpClient? httpClient, TestRestOptions options) 
+            : base(logger, httpClient, options.Environment.RestClientAddress, options, options.ExchangeOptions)
+        {
+        }
+
+
+        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode tradingMode, DateTime? deliverDate = null) =>
+            baseAsset + quoteAsset;
+
+        protected override TestAuthenticationProvider CreateAuthenticationProvider(TestCredentials credentials) =>
+            new TestAuthenticationProvider(credentials);
+
+        protected override IMessageSerializer CreateSerializer() => new SystemTextJsonMessageSerializer(SerializerOptions.WithConverters(new TestSerializerContext()));
+
+        internal void SetNextResponse(string data, HttpStatusCode code)
+        {
+            var expectedBytes = Encoding.UTF8.GetBytes(data);
+            var responseStream = new MemoryStream();
+            responseStream.Write(expectedBytes, 0, expectedBytes.Length);
+            responseStream.Seek(0, SeekOrigin.Begin);
+
+            var response = new TestResponse(code, responseStream);
+            var request = new TestRequest(response);
+
+            var factory = new TestRequestFactory(request);
+            RequestFactory = factory;
+        }
+
+        internal async Task<WebCallResult<T>> GetResponseAsync<T>(HttpMethod? httpMethod = null, ParameterCollection? collection = null, RateLimitGate? rateLimitGate = null)
+        {
+            var definition = new RequestDefinition("/path", httpMethod ?? HttpMethod.Get)
+            {
+                Weight = rateLimitGate == null ? 0 : 1,
+                RateLimitGate = rateLimitGate
+            };
+            return await SendAsync<T>(BaseAddress, definition, collection ?? new ParameterCollection(), default);
+        }
+
+        internal void SetParameterPosition(HttpMethod httpMethod, HttpMethodParameterPosition pos)
+        {
+            ParameterPositions[httpMethod] = pos;
+        }
+    }
+}

CryptoExchange.Net.UnitTests/Implementations/TestRestClient.cs

@@ -0,0 +1,27 @@
+using CryptoExchange.Net.Clients;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using System;
+using System.Net.Http;
+
+namespace CryptoExchange.Net.UnitTests.Implementations
+{
+    internal class TestRestClient : BaseRestClient<TestEnvironment, TestCredentials>
+    {
+        public TestRestApiClient ApiClient1 { get; set; }
+        public TestRestApiClient ApiClient2 { get; set; }
+
+        public TestRestClient(Action<TestRestOptions>? optionsDelegate = null)
+            : this(null, null, Options.Create(ApplyOptionsDelegate(optionsDelegate)))
+        {
+        }
+
+        public TestRestClient(HttpClient? httpClient, ILoggerFactory? loggerFactory, IOptions<TestRestOptions> options) : base(loggerFactory, "Test")
+        {
+            Initialize(options.Value);
+
+            ApiClient1 = AddApiClient(new TestRestApiClient(_logger, httpClient, options.Value));
+            ApiClient2 = AddApiClient(new TestRestApiClient(_logger, httpClient, options.Value));
+        }
+    }
+}

CryptoExchange.Net.UnitTests/Implementations/TestRestMessageHandler.cs

@@ -0,0 +1,33 @@
+using CryptoExchange.Net.Converters.SystemTextJson;
+using CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
+using System.IO;
+using System.Net.Http.Headers;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.UnitTests.Implementations
+{
+    internal class TestRestMessageHandler : JsonRestMessageHandler
+    {
+        public override JsonSerializerOptions Options { get; } = SerializerOptions.WithConverters(new TestSerializerContext());
+
+        public override async ValueTask<Error> ParseErrorResponse(int httpStatusCode, HttpResponseHeaders responseHeaders, Stream responseStream)
+        {
+            var (jsonError, jsonDocument) = await GetJsonDocument(responseStream).ConfigureAwait(false);
+            if (jsonError != null)
+                return jsonError;
+
+            int? code = jsonDocument!.RootElement.TryGetProperty("errorCode", out var codeProp) ? codeProp.GetInt32() : null;
+            var msg = jsonDocument.RootElement.TryGetProperty("errorMessage", out var msgProp) ? msgProp.GetString() : null;
+            if (msg == null)
+                return new ServerError(ErrorInfo.Unknown);
+
+            if (code == null)
+                return new ServerError(ErrorInfo.Unknown with { Message = msg });
+
+            return new ServerError(code.Value, new ErrorInfo(ErrorType.Unknown, false, "Error") with { Message = msg });
+        }
+    }
+}

CryptoExchange.Net.UnitTests/Implementations/TestRestOptions.cs

@@ -0,0 +1,27 @@
+using CryptoExchange.Net.Objects.Options;
+
+namespace CryptoExchange.Net.UnitTests.Implementations
+{
+    internal class TestRestOptions : RestExchangeOptions<TestEnvironment, TestCredentials>
+    {
+        internal static TestRestOptions Default { get; set; } = new TestRestOptions()
+        {
+            Environment = TestEnvironment.Live,
+            AutoTimestamp = true
+        };
+
+        public TestRestOptions()
+        {
+            Default?.Set(this);
+        }
+
+        public RestApiOptions ExchangeOptions { get; private set; } = new RestApiOptions();
+
+        internal TestRestOptions Set(TestRestOptions targetOptions)
+        {
+            targetOptions = base.Set<TestRestOptions>(targetOptions);
+            targetOptions.ExchangeOptions = ExchangeOptions.Set(targetOptions.ExchangeOptions);
+            return targetOptions;
+        }
+    }
+}

CryptoExchange.Net.UnitTests/Implementations/TestSerializerContext.cs

@@ -0,0 +1,29 @@
+using CryptoExchange.Net.UnitTests.ConverterTests;
+using CryptoExchange.Net.UnitTests.Implementations;
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.UnitTests
+{
+    [JsonSerializable(typeof(string))]
+    [JsonSerializable(typeof(int))]
+    [JsonSerializable(typeof(Dictionary<string, string>))]
+    [JsonSerializable(typeof(IDictionary<string, string>))]
+    [JsonSerializable(typeof(Dictionary<string, object>))]
+    [JsonSerializable(typeof(IDictionary<string, object>))]
+    [JsonSerializable(typeof(TestObject))]
+
+    [JsonSerializable(typeof(TestSocketMessage))]
+    [JsonSerializable(typeof(Test))]
+    [JsonSerializable(typeof(Test2))]
+    [JsonSerializable(typeof(Test3))]
+    [JsonSerializable(typeof(NotNullableSTJBoolObject))]
+    [JsonSerializable(typeof(STJBoolObject))]
+    [JsonSerializable(typeof(NotNullableSTJEnumObject))]
+    [JsonSerializable(typeof(STJEnumObject))]
+    [JsonSerializable(typeof(STJDecimalObject))]
+    [JsonSerializable(typeof(STJTimeObject))]
+    internal partial class TestSerializerContext : JsonSerializerContext
+    {
+    }
+}

CryptoExchange.Net.UnitTests/Implementations/TestSocketApiClient.cs

@@ -0,0 +1,44 @@
+using CryptoExchange.Net.Clients;
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
+using CryptoExchange.Net.Converters.SystemTextJson;
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.SharedApis;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Net.Http;
+using System.Net.WebSockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.UnitTests.Implementations
+{
+    internal class TestSocketApiClient : SocketApiClient<TestEnvironment, TestAuthenticationProvider, TestCredentials>
+    {
+        public TestSocketApiClient(ILogger logger, TestSocketOptions options)
+            : base(logger, options.Environment.SocketClientAddress, options, options.ExchangeOptions)
+        {
+        }
+
+        public TestSocketApiClient(ILogger logger, HttpClient httpClient, string baseAddress, TestSocketOptions options, SocketApiOptions apiOptions)
+            : base(logger, baseAddress, options, apiOptions)
+        {
+        }
+
+        public override ISocketMessageHandler CreateMessageConverter(WebSocketMessageType messageType) => new TestSocketMessageHandler();
+        protected internal override IMessageSerializer CreateSerializer() => new SystemTextJsonMessageSerializer(SerializerOptions.WithConverters(new TestSerializerContext()));
+
+        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode tradingMode, DateTime? deliverDate = null) =>
+            baseAsset + quoteAsset;
+
+        protected override TestAuthenticationProvider CreateAuthenticationProvider(TestCredentials credentials) =>
+            new TestAuthenticationProvider(credentials);
+
+        public async Task<CallResult<UpdateSubscription>> SubscribeToUpdatesAsync<T>(Action<DataEvent<T>> handler, bool subQuery, CancellationToken ct)
+        {
+            return await base.SubscribeAsync(new TestSubscription<T>(_logger, handler, subQuery, false), ct);
+        }
+    }
+}

CryptoExchange.Net.UnitTests/Implementations/TestSocketClient.cs

@@ -0,0 +1,26 @@
+using CryptoExchange.Net.Clients;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using System;
+
+namespace CryptoExchange.Net.UnitTests.Implementations
+{
+    internal class TestSocketClient : BaseSocketClient<TestEnvironment, TestCredentials>
+    {
+        public TestSocketApiClient ApiClient1 { get; set; }
+        public TestSocketApiClient ApiClient2 { get; set; }
+
+        public TestSocketClient(Action<TestSocketOptions>? optionsDelegate = null)
+            : this(null, Options.Create(ApplyOptionsDelegate(optionsDelegate)))
+        {
+        }
+
+        public TestSocketClient(ILoggerFactory? loggerFactory, IOptions<TestSocketOptions> options) : base(loggerFactory, "Test")
+        {
+            Initialize(options.Value);
+
+            ApiClient1 = AddApiClient(new TestSocketApiClient(_logger, options.Value));
+            ApiClient2 = AddApiClient(new TestSocketApiClient(_logger, options.Value));
+        }
+    }
+}

CryptoExchange.Net.UnitTests/Implementations/TestSocketMessage.cs

@@ -0,0 +1,16 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.UnitTests.Implementations
+{
+    internal record TestSocketMessage
+    {
+        [JsonPropertyName("id")]
+        public int Id { get; set; }
+        [JsonPropertyName("data")]
+        public string Data { get; set; } = string.Empty;
+    }
+}

CryptoExchange.Net.UnitTests/Implementations/TestSocketMessageHandler.cs

@@ -0,0 +1,33 @@
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
+using CryptoExchange.Net.Converters.SystemTextJson;
+using CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers;
+using System.Text.Json;
+
+namespace CryptoExchange.Net.UnitTests.Implementations
+{
+    internal class TestSocketMessageHandler : JsonSocketMessageHandler
+    {
+        public override JsonSerializerOptions Options { get; } = SerializerOptions.WithConverters(new TestSerializerContext());
+
+        public TestSocketMessageHandler()
+        {
+        }
+
+        protected override MessageTypeDefinition[] TypeEvaluators { get; } = [
+
+             new MessageTypeDefinition {
+                ForceIfFound = true,
+                Fields = [
+                    new PropertyFieldReference("id")
+                ],
+                TypeIdentifierCallback = (doc) => doc.FieldValue("id")!
+            },
+
+            new MessageTypeDefinition {
+                Fields = [
+                ],
+                StaticIdentifier = "test"
+            },
+        ];
+    }
+}

CryptoExchange.Net.UnitTests/Implementations/TestSocketOptions.cs

@@ -0,0 +1,27 @@
+using CryptoExchange.Net.Objects.Options;
+
+namespace CryptoExchange.Net.UnitTests.Implementations
+{
+    internal class TestSocketOptions : SocketExchangeOptions<TestEnvironment, TestCredentials>
+    {
+        internal static TestSocketOptions Default { get; set; } = new TestSocketOptions()
+        {
+            Environment = TestEnvironment.Live,
+            AutoTimestamp = true
+        };
+
+        public TestSocketOptions()
+        {
+            Default?.Set(this);
+        }
+
+        public SocketApiOptions ExchangeOptions { get; private set; } = new SocketApiOptions();
+
+        internal TestSocketOptions Set(TestSocketOptions targetOptions)
+        {
+            targetOptions = base.Set<TestSocketOptions>(targetOptions);
+            targetOptions.ExchangeOptions = ExchangeOptions.Set(targetOptions.ExchangeOptions);
+            return targetOptions;
+        }
+    }
+}

CryptoExchange.Net.UnitTests/Implementations/TestSubscription.cs

@@ -0,0 +1,50 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Sockets;
+using CryptoExchange.Net.Sockets.Default;
+using CryptoExchange.Net.Sockets.Default.Routing;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Reflection.Metadata;
+using System.Text;
+
+namespace CryptoExchange.Net.UnitTests.Implementations
+{
+    internal class TestSubscription<T> : Subscription
+    {
+        private readonly Action<DataEvent<T>> _handler;
+        private bool _subQuery;
+
+        public TestSubscription(ILogger logger, Action<DataEvent<T>> handler, bool subQuery, bool authenticated) : base(logger, authenticated, true)
+        {
+            _handler = handler;
+            _subQuery = subQuery;
+
+            MessageRouter = MessageRouter.CreateWithoutTopicFilter<T>("test", HandleUpdate);
+        }
+
+        protected override Query? GetSubQuery(SocketConnection connection)
+        {
+            if (!_subQuery)
+                return null;
+
+            return new TestQuery(new TestSocketMessage { Id = 1, Data = "Sub" }, false);
+        }
+
+        protected override Query? GetUnsubQuery(SocketConnection connection)
+        {
+            if (!_subQuery)
+                return null;
+
+            return new TestQuery(new TestSocketMessage { Id = 2, Data = "Unsub" }, false);
+        }
+
+
+        private CallResult? HandleUpdate(SocketConnection connection, DateTime time, string? originalData, T data)
+        {
+            _handler(new DataEvent<T>("Test", data, time, originalData));
+            return CallResult.SuccessResult;
+        }
+    }
+}

CryptoExchange.Net.UnitTests/OptionsTests.cs

@@ -1,6 +1,7 @@
 using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Options;
-using CryptoExchange.Net.UnitTests.TestImplementations;
+using CryptoExchange.Net.UnitTests.Implementations;
 using NUnit.Framework;
 using System;
 
@@ -10,9 +11,9 @@ namespace CryptoExchange.Net.UnitTests
     public class OptionsTests
     {
         [TearDown]
-        public void Init()
+        public void TearDown()
         {
-            TestClientOptions.Default = new TestClientOptions
+            TestRestOptions.Default = new TestRestOptions
             {
             };
         }
@@ -29,135 +30,123 @@ namespace CryptoExchange.Net.UnitTests
             // act
             // assert
             Assert.Throws(typeof(ArgumentException),
-                () => new RestExchangeOptions<TestEnvironment, ApiCredentials>() { ApiCredentials = new ApiCredentials(key, secret) });
+                () => {
+                    var opts = new TestRestOptions()
+                    {
+                        ApiCredentials = new TestCredentials(key, secret)
+                    };
+                    opts.ApiCredentials.Validate();
+                });
         }
 
         [Test]
         public void TestBasicOptionsAreSet()
         {
             // arrange, act
-            var options = new TestClientOptions
+            var options = new TestRestOptions
             {
-                ApiCredentials = new ApiCredentials("123", "456"),
-                ReceiveWindow = TimeSpan.FromSeconds(10)
+                ApiCredentials = new TestCredentials("123", "456"),
+                RequestTimeout = TimeSpan.FromSeconds(10)
             };
 
             // assert
-            Assert.That(options.ReceiveWindow == TimeSpan.FromSeconds(10));
+            Assert.That(options.RequestTimeout == TimeSpan.FromSeconds(10));
             Assert.That(options.ApiCredentials.Key == "123");
             Assert.That(options.ApiCredentials.Secret == "456");
         }
 
         [Test]
-        public void TestApiOptionsAreSet()
+        public void TestSetOptionsRest()
         {
-            // arrange, act
-            var options = new TestClientOptions();
-            options.Api1Options.ApiCredentials = new ApiCredentials("123", "456");
-            options.Api2Options.ApiCredentials = new ApiCredentials("789", "101");
-
-            // assert
-            Assert.That(options.Api1Options.ApiCredentials.Key == "123");
-            Assert.That(options.Api1Options.ApiCredentials.Secret == "456");
-            Assert.That(options.Api2Options.ApiCredentials.Key == "789");
-            Assert.That(options.Api2Options.ApiCredentials.Secret == "101");
-        }
-
-        [Test]
-        public void TestClientUsesCorrectOptions()
-        {
-            var client = new TestRestClient(options => {
-                options.Api1Options.ApiCredentials = new ApiCredentials("111", "222");
-                options.ApiCredentials = new ApiCredentials("333", "444");
-            });
-
-            var authProvider1 = (TestAuthProvider)client.Api1.AuthenticationProvider;
-            var authProvider2 = (TestAuthProvider)client.Api2.AuthenticationProvider;
-            Assert.That(authProvider1.GetKey() == "111");
-            Assert.That(authProvider1.GetSecret() == "222");
-            Assert.That(authProvider2.GetKey() == "333");
-            Assert.That(authProvider2.GetSecret() == "444");
-        }
-
-        [Test]
-        public void TestClientUsesCorrectOptionsWithDefault()
-        {
-            TestClientOptions.Default.ApiCredentials = new ApiCredentials("123", "456");
-            TestClientOptions.Default.Api1Options.ApiCredentials = new ApiCredentials("111", "222");
-
             var client = new TestRestClient();
+            client.SetOptions(new UpdateOptions
+            {
+                RequestTimeout = TimeSpan.FromSeconds(2),
+                Proxy = new ApiProxy("http://testproxy", 1234)
+            });
 
-            var authProvider1 = (TestAuthProvider)client.Api1.AuthenticationProvider;
-            var authProvider2 = (TestAuthProvider)client.Api2.AuthenticationProvider;
-            Assert.That(authProvider1.GetKey() == "111");
-            Assert.That(authProvider1.GetSecret() == "222");
-            Assert.That(authProvider2.GetKey() == "123");
-            Assert.That(authProvider2.GetSecret() == "456");
-
-            // Cleanup static values
-            TestClientOptions.Default.ApiCredentials = null;
-            TestClientOptions.Default.Api1Options.ApiCredentials = null;
+            Assert.That(client.ApiClient1.ClientOptions.Proxy, Is.Not.Null);
+            Assert.That(client.ApiClient1.ClientOptions.Proxy!.Host, Is.EqualTo("http://testproxy"));
+            Assert.That(client.ApiClient1.ClientOptions.Proxy.Port, Is.EqualTo(1234));
+            Assert.That(client.ApiClient1.ClientOptions.RequestTimeout, Is.EqualTo(TimeSpan.FromSeconds(2)));
         }
 
         [Test]
-        public void TestClientUsesCorrectOptionsWithOverridingDefault()
+        public void TestSetOptionsRestWithCredentials()
         {
-            TestClientOptions.Default.ApiCredentials = new ApiCredentials("123", "456");
-            TestClientOptions.Default.Api1Options.ApiCredentials = new ApiCredentials("111", "222");
-
-            var client = new TestRestClient(options =>
+            var client = new TestRestClient();
+            client.SetOptions(new UpdateOptions<TestCredentials>
             {
-                options.Api1Options.ApiCredentials = new ApiCredentials("333", "444");
-                options.Environment = new TestEnvironment("Test", "https://test.test");
+                ApiCredentials = new TestCredentials("123", "456"),
+                RequestTimeout = TimeSpan.FromSeconds(2),
+                Proxy = new ApiProxy("http://testproxy", 1234)
             });
 
-            var authProvider1 = (TestAuthProvider)client.Api1.AuthenticationProvider;
-            var authProvider2 = (TestAuthProvider)client.Api2.AuthenticationProvider;
-            Assert.That(authProvider1.GetKey() == "333");
-            Assert.That(authProvider1.GetSecret() == "444");
-            Assert.That(authProvider2.GetKey() == "123");
-            Assert.That(authProvider2.GetSecret() == "456");
-            Assert.That(client.Api2.BaseAddress == "https://localhost:123");
+            Assert.That(client.ApiClient1.ApiCredentials, Is.Not.Null);
+            Assert.That(client.ApiClient1.ApiCredentials!.Key, Is.EqualTo("123"));
+            Assert.That(client.ApiClient1.ClientOptions.Proxy, Is.Not.Null);
+            Assert.That(client.ApiClient1.ClientOptions.Proxy!.Host, Is.EqualTo("http://testproxy"));
+            Assert.That(client.ApiClient1.ClientOptions.Proxy.Port, Is.EqualTo(1234));
+            Assert.That(client.ApiClient1.ClientOptions.RequestTimeout, Is.EqualTo(TimeSpan.FromSeconds(2)));
+        }
 
-            // Cleanup static values
-            TestClientOptions.Default.ApiCredentials = null;
-            TestClientOptions.Default.Api1Options.ApiCredentials = null;
+        [Test]
+        public void TestWhenUpdatingSettingsExistingClientsAreNotAffected()
+        {
+            TestRestOptions.Default = new TestRestOptions
+            {
+                ApiCredentials = new TestCredentials("111", "222"),
+                RequestTimeout = TimeSpan.FromSeconds(1),
+            };
+
+            var client1 = new TestRestClient();
+
+            Assert.That(client1.ClientOptions.RequestTimeout, Is.EqualTo(TimeSpan.FromSeconds(1)));
+            Assert.That(client1.ClientOptions.ApiCredentials!.Key, Is.EqualTo("111"));
+
+            TestRestOptions.Default.ApiCredentials = new TestCredentials("333", "444");
+            TestRestOptions.Default.RequestTimeout = TimeSpan.FromSeconds(2);
+
+            var client2 = new TestRestClient();
+
+            Assert.That(client2.ClientOptions.RequestTimeout, Is.EqualTo(TimeSpan.FromSeconds(2)));
+            Assert.That(client2.ClientOptions.ApiCredentials!.Key, Is.EqualTo("333"));
         }
     }
 
-    public class TestClientOptions: RestExchangeOptions<TestEnvironment, ApiCredentials>
-    {
-        /// <summary>
-        /// Default options for the futures client
-        /// </summary>
-        public static TestClientOptions Default { get; set; } = new TestClientOptions()
-        {
-            Environment = new TestEnvironment("test", "https://test.com")
-        };
+    //public class TestClientOptions: RestExchangeOptions<TestEnvironment, HMACCredential>
+    //{
+    //    /// <summary>
+    //    /// Default options for the futures client
+    //    /// </summary>
+    //    public static TestClientOptions Default { get; set; } = new TestClientOptions()
+    //    {
+    //        Environment = new TestEnvironment("test", "https://test.com")
+    //    };
 
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public TestClientOptions()
-        {
-            Default?.Set(this);
-        }
+    //    /// <summary>
+    //    /// ctor
+    //    /// </summary>
+    //    public TestClientOptions()
+    //    {
+    //        Default?.Set(this);
+    //    }
 
-        /// <summary>
-        /// The default receive window for requests
-        /// </summary>
-        public TimeSpan ReceiveWindow { get; set; } = TimeSpan.FromSeconds(5);
+    //    /// <summary>
+    //    /// The default receive window for requests
+    //    /// </summary>
+    //    public TimeSpan ReceiveWindow { get; set; } = TimeSpan.FromSeconds(5);
 
-        public RestApiOptions Api1Options { get; private set; } = new RestApiOptions();
+    //    public RestApiOptions Api1Options { get; private set; } = new RestApiOptions();
 
-        public RestApiOptions Api2Options { get; set; } = new RestApiOptions();
+    //    public RestApiOptions Api2Options { get; set; } = new RestApiOptions();
 
-        internal TestClientOptions Set(TestClientOptions targetOptions)
-        {
-            targetOptions = base.Set<TestClientOptions>(targetOptions);
-            targetOptions.Api1Options = Api1Options.Set(targetOptions.Api1Options);
-            targetOptions.Api2Options = Api2Options.Set(targetOptions.Api2Options);
-            return targetOptions;
-        }
-    }
+    //    internal TestClientOptions Set(TestClientOptions targetOptions)
+    //    {
+    //        targetOptions = base.Set<TestClientOptions>(targetOptions);
+    //        targetOptions.Api1Options = Api1Options.Set(targetOptions.Api1Options);
+    //        targetOptions.Api2Options = Api2Options.Set(targetOptions.Api2Options);
+    //        return targetOptions;
+    //    }
+    //}
 }

CryptoExchange.Net.UnitTests/ParameterCollectionTests.cs

@@ -0,0 +1,331 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.UnitTests.ConverterTests;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CryptoExchange.Net.UnitTests
+{
+    internal class ParameterCollectionTests
+    {
+        [Test]
+        public void AddingBasicValue_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.Add("test", "value");
+            Assert.That(parameters["test"], Is.EqualTo("value"));
+        }
+
+        [Test]
+        public void AddingBasicNullValue_ThrowsException()
+        {
+            var parameters = new ParameterCollection();
+            Assert.Throws<ArgumentNullException>(() =>  parameters.Add("test", null!));
+        }
+
+        [Test]
+        public void AddingOptionalBasicValue_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptional("test", "value");
+            Assert.That(parameters["test"], Is.EqualTo("value"));
+        }
+
+        [Test]
+        public void AddingOptionalBasicNullValue_DoesntSetValue()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptional("test", null);
+            Assert.That(parameters.ContainsKey("test"), Is.False);
+        }
+
+        [Test]
+        public void AddingDecimalValueAsString_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddString("test", 0.1m);
+            Assert.That(parameters["test"], Is.EqualTo("0.1"));
+        }
+
+        [Test]
+        public void AddingOptionalDecimalValueAsString_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalString("test", 0.1m);
+            Assert.That(parameters["test"], Is.EqualTo("0.1"));
+        }
+
+        [Test]
+        public void AddingOptionalDecimalNullValueAsString_DoesntSetValue()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalString("test", (decimal?)null);
+            Assert.That(parameters.ContainsKey("test"), Is.False);
+        }
+
+        [Test]
+        public void AddingIntValueAsString_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddString("test", 1);
+            Assert.That(parameters["test"], Is.EqualTo("1"));
+        }
+
+        [Test]
+        public void AddingOptionalIntValueAsString_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalString("test", 1);
+            Assert.That(parameters["test"], Is.EqualTo("1"));
+        }
+
+        [Test]
+        public void AddingOptionalIntNullValueAsString_DoesntSetValue()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalString("test", (int?)null);
+            Assert.That(parameters.ContainsKey("test"), Is.False);
+        }
+
+        [Test]
+        public void AddingLongValueAsString_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddString("test", 1L);
+            Assert.That(parameters["test"], Is.EqualTo("1"));
+        }
+
+        [Test]
+        public void AddingOptionalLongValueAsString_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalString("test", 1L);
+            Assert.That(parameters["test"], Is.EqualTo("1"));
+        }
+
+        [Test]
+        public void AddingOptionalLongNullValueAsString_DoesntSetValue()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalString("test", (long?)null);
+            Assert.That(parameters.ContainsKey("test"), Is.False);
+        }
+
+        [Test]
+        public void AddingMillisecondTimestamp_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddMilliseconds("test", new DateTime(2025, 1, 1, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(parameters["test"], Is.EqualTo(1735689600000));
+        }
+
+        [Test]
+        public void AddingOptionalMillisecondTimestamp_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalMilliseconds("test", new DateTime(2025, 1, 1, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(parameters["test"], Is.EqualTo(1735689600000));
+        }
+
+        [Test]
+        public void AddingOptionalMillisecondNullValue_DoesntSetValue()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalMilliseconds("test", null);
+            Assert.That(parameters.ContainsKey("test"), Is.False);
+        }
+
+        [Test]
+        public void AddingMillisecondTimestampString_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddMillisecondsString("test", new DateTime(2025, 1, 1, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(parameters["test"], Is.EqualTo("1735689600000"));
+        }
+
+        [Test]
+        public void AddingOptionalMillisecondTimestampString_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalMillisecondsString("test", new DateTime(2025, 1, 1, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(parameters["test"], Is.EqualTo("1735689600000"));
+        }
+
+        [Test]
+        public void AddingOptionalMillisecondStringNullValue_DoesntSetValue()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalMillisecondsString("test", null);
+            Assert.That(parameters.ContainsKey("test"), Is.False);
+        }
+
+        [Test]
+        public void AddingSecondTimestamp_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddSeconds("test", new DateTime(2025, 1, 1, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(parameters["test"], Is.EqualTo(1735689600));
+        }
+
+        [Test]
+        public void AddingOptionalSecondTimestamp_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalSeconds("test", new DateTime(2025, 1, 1, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(parameters["test"], Is.EqualTo(1735689600));
+        }
+
+        [Test]
+        public void AddingSecondNullValue_DoesntSetValue()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalSeconds("test", null);
+            Assert.That(parameters.ContainsKey("test"), Is.False);
+        }
+
+        [Test]
+        public void AddingSecondTimestampString_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddSecondsString("test", new DateTime(2025, 1, 1, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(parameters["test"], Is.EqualTo("1735689600"));
+        }
+
+        [Test]
+        public void AddingOptionalSecondTimestampString_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalSecondsString("test", new DateTime(2025, 1, 1, 0, 0, 0, DateTimeKind.Utc));
+            Assert.That(parameters["test"], Is.EqualTo("1735689600"));
+        }
+
+        [Test]
+        public void AddingSecondStringNullValue_DoesntSetValue()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalSecondsString("test", null);
+            Assert.That(parameters.ContainsKey("test"), Is.False);
+        }
+
+        [Test]
+        public void AddingEnum_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddEnum("test", TestEnum.Two);
+            Assert.That(parameters["test"], Is.EqualTo("2"));
+        }
+
+        [Test]
+        public void AddingOptionalEnum_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalEnum("test", (TestEnum?)TestEnum.Two);
+            Assert.That(parameters["test"], Is.EqualTo("2"));
+        }
+
+        [Test]
+        public void AddingOptionalEnumNullValue_DoesntSetValue()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalEnum("test", (TestEnum?)null);
+            Assert.That(parameters.ContainsKey("test"), Is.False);
+        }
+
+        [Test]
+        public void AddingEnumAsInt_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddEnumAsInt("test", TestEnum.Two);
+            Assert.That(parameters["test"], Is.EqualTo(2));
+        }
+
+        [Test]
+        public void AddingOptionalEnumAsInt_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalEnumAsInt("test", (TestEnum?)TestEnum.Two);
+            Assert.That(parameters["test"], Is.EqualTo(2));
+        }
+
+        [Test]
+        public void AddingOptionalEnumAsIntNullValue_DoesntSetValue()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalEnumAsInt("test", (TestEnum?)null);
+            Assert.That(parameters.ContainsKey("test"), Is.False);
+        }
+
+        [Test]
+        public void AddingCommaSeparated_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddCommaSeparated("test", ["1", "2"]);
+            Assert.That(parameters["test"], Is.EqualTo("1,2"));
+        }
+
+        [Test]
+        public void AddingOptionalCommaSeparated_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalCommaSeparated("test", ["1", "2"]);
+            Assert.That(parameters["test"], Is.EqualTo("1,2"));
+        }
+
+        [Test]
+        public void AddingOptionalCommaSeparatedNullValue_DoesntSetValue()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalCommaSeparated("test", (string[]?)null);
+            Assert.That(parameters.ContainsKey("test"), Is.False);
+        }
+
+        [Test]
+        public void AddingCommaSeparatedEnum_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddCommaSeparated("test", [TestEnum.Two, TestEnum.One]);
+            Assert.That(parameters["test"], Is.EqualTo("2,1"));
+        }
+
+        [Test]
+        public void AddingOptionalCommaSeparatedEnum_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalCommaSeparated("test", [TestEnum.Two, TestEnum.One]);
+            Assert.That(parameters["test"], Is.EqualTo("2,1"));
+        }
+
+        [Test]
+        public void AddingOptionalCommaSeparatedEnumNullValue_DoesntSetValue()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalCommaSeparated("test", (TestEnum[]?)null);
+            Assert.That(parameters.ContainsKey("test"), Is.False);
+        }
+
+        [Test]
+        public void AddingBoolString_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddBoolString("test", true);
+            Assert.That(parameters["test"], Is.EqualTo("true"));
+        }
+
+        [Test]
+        public void AddingOptionalBoolString_SetValueCorrectly()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalBoolString("test", true);
+            Assert.That(parameters["test"], Is.EqualTo("true"));
+        }
+
+        [Test]
+        public void AddingOptionalBoolStringNullValue_DoesntSetValue()
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalBoolString("test", null);
+            Assert.That(parameters.ContainsKey("test"), Is.False);
+        }
+    }
+}

CryptoExchange.Net.UnitTests/RateLimitTests.cs

@@ -1,159 +1,23 @@
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.UnitTests.TestImplementations;
+using CryptoExchange.Net.RateLimiting;
+using CryptoExchange.Net.RateLimiting.Filters;
+using CryptoExchange.Net.RateLimiting.Guards;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using CryptoExchange.Net.UnitTests.Implementations;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Net.Http;
-using System.Threading.Tasks;
-using System.Threading;
-using NUnit.Framework.Legacy;
-using CryptoExchange.Net.RateLimiting;
-using CryptoExchange.Net.RateLimiting.Guards;
-using CryptoExchange.Net.RateLimiting.Filters;
-using CryptoExchange.Net.RateLimiting.Interfaces;
+using System.Text;
 using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace CryptoExchange.Net.UnitTests
 {
     [TestFixture()]
-    public class RestClientTests
+    public class RateLimitTests
     {
-        [TestCase]
-        public void RequestingData_Should_ResultInData()
-        {
-            // arrange
-            var client = new TestRestClient();
-            var expected = new TestObject() { DecimalData = 1.23M, IntData = 10, StringData = "Some data" };
-            client.SetResponse(JsonSerializer.Serialize(expected, new JsonSerializerOptions { TypeInfoResolver = new TestSerializerContext() }), out _);
-
-            // act
-            var result = client.Api1.Request<TestObject>().Result;
-
-            // assert
-            Assert.That(result.Success);
-            Assert.That(TestHelpers.AreEqual(expected, result.Data));
-        }
-
-        [TestCase]
-        public void ReceivingInvalidData_Should_ResultInError()
-        {
-            // arrange
-            var client = new TestRestClient();
-            client.SetResponse("{\"property\": 123", out _);
-
-            // act
-            var result = client.Api1.Request<TestObject>().Result;
-
-            // assert
-            ClassicAssert.IsFalse(result.Success);
-            Assert.That(result.Error != null);
-        }
-
-        [TestCase]
-        public async Task ReceivingErrorCode_Should_ResultInError()
-        {
-            // arrange
-            var client = new TestRestClient();
-            client.SetErrorWithoutResponse(System.Net.HttpStatusCode.BadRequest, "Invalid request");
-
-            // act
-            var result = await client.Api1.Request<TestObject>();
-
-            // assert
-            ClassicAssert.IsFalse(result.Success);
-            Assert.That(result.Error != null);
-        }
-
-        [TestCase]
-        public async Task ReceivingErrorAndNotParsingError_Should_ResultInFlatError()
-        {
-            // arrange
-            var client = new TestRestClient();
-            client.SetErrorWithResponse("{\"errorMessage\": \"Invalid request\", \"errorCode\": 123}", System.Net.HttpStatusCode.BadRequest);
-
-            // act
-            var result = await client.Api1.Request<TestObject>();
-
-            // assert
-            ClassicAssert.IsFalse(result.Success);
-            Assert.That(result.Error != null);
-            Assert.That(result.Error is ServerError);
-        }
-
-        [TestCase]
-        public async Task ReceivingErrorAndParsingError_Should_ResultInParsedError()
-        {
-            // arrange
-            var client = new ParseErrorTestRestClient();
-            client.SetErrorWithResponse("{\"errorMessage\": \"Invalid request\", \"errorCode\": 123}", System.Net.HttpStatusCode.BadRequest);
-
-            // act
-            var result = await client.Api2.Request<TestObject>();
-
-            // assert
-            ClassicAssert.IsFalse(result.Success);
-            Assert.That(result.Error != null);
-            Assert.That(result.Error is ServerError);
-            Assert.That(result.Error.ErrorCode == "123");
-            Assert.That(result.Error.Message == "Invalid request");
-        }
-
-        [TestCase]
-        public void SettingOptions_Should_ResultInOptionsSet()
-        {
-            // arrange
-            // act
-            var options = new TestClientOptions();
-            options.Api1Options.TimestampRecalculationInterval = TimeSpan.FromMinutes(10);
-            options.Api1Options.OutputOriginalData = true;
-            options.RequestTimeout = TimeSpan.FromMinutes(1);
-            var client = new TestBaseClient(options);
-
-            // assert
-            Assert.That(((TestClientOptions)client.ClientOptions).Api1Options.TimestampRecalculationInterval == TimeSpan.FromMinutes(10));
-            Assert.That(((TestClientOptions)client.ClientOptions).Api1Options.OutputOriginalData == true);
-            Assert.That(((TestClientOptions)client.ClientOptions).RequestTimeout == TimeSpan.FromMinutes(1));
-        }
-
-        [TestCase("GET", HttpMethodParameterPosition.InUri)] // No need to test InBody for GET since thats not valid
-        [TestCase("POST", HttpMethodParameterPosition.InBody)]
-        [TestCase("POST", HttpMethodParameterPosition.InUri)]
-        [TestCase("DELETE", HttpMethodParameterPosition.InBody)]
-        [TestCase("DELETE", HttpMethodParameterPosition.InUri)]
-        [TestCase("PUT", HttpMethodParameterPosition.InUri)]
-        [TestCase("PUT", HttpMethodParameterPosition.InBody)]
-        public async Task Setting_Should_ResultInOptionsSet(string method, HttpMethodParameterPosition pos)
-        {
-            // arrange
-            // act
-            var client = new TestRestClient();
-
-            client.Api1.SetParameterPosition(new HttpMethod(method), pos);
-
-            client.SetResponse("{}", out var request);
-
-            await client.Api1.RequestWithParams<TestObject>(new HttpMethod(method), new ParameterCollection
-            {
-                { "TestParam1", "Value1" },
-                { "TestParam2", 2 },
-            },
-            new Dictionary<string, string>
-            {
-                { "TestHeader", "123" }
-            });
-
-            // assert
-            Assert.That(request.Method == new HttpMethod(method));
-            Assert.That((request.Content?.Contains("TestParam1") == true) == (pos == HttpMethodParameterPosition.InBody));
-            Assert.That((request.Uri.ToString().Contains("TestParam1")) == (pos == HttpMethodParameterPosition.InUri));
-            Assert.That((request.Content?.Contains("TestParam2") == true) == (pos == HttpMethodParameterPosition.InBody));
-            Assert.That((request.Uri.ToString().Contains("TestParam2")) == (pos == HttpMethodParameterPosition.InUri));
-            Assert.That(request.GetHeaders().First().Key == "TestHeader");
-            Assert.That(request.GetHeaders().First().Value.Contains("123"));
-        }
-
-
         [TestCase(1, 0.1)]
         [TestCase(2, 0.1)]
         [TestCase(5, 1)]
@@ -169,12 +33,12 @@ namespace CryptoExchange.Net.UnitTests
 
             for (var i = 0; i < requests + 1; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, null, default);             
-                Assert.That(i == requests? triggered : !triggered);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, null, default);
+                Assert.That(i == requests ? triggered : !triggered);
             }
             triggered = false;
             await Task.Delay((int)Math.Round(perSeconds * 1000) + 10);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1,  RateLimitingBehaviour.Wait, null, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, null, default);
             Assert.That(!triggered);
         }
 
@@ -190,12 +54,12 @@ namespace CryptoExchange.Net.UnitTests
 
             var requestDefinition = new RequestDefinition(endpoint, HttpMethod.Get);
 
-            RateLimitEvent evnt = null;
+            RateLimitEvent? evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
                 var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, null, default);
-                bool expected = i == 1 ? (expectLimiting ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
+                bool expected = i == 1 ? expectLimiting ? evnt?.DelayTime > TimeSpan.Zero : evnt == null : evnt == null;
                 Assert.That(expected);
             }
         }
@@ -212,7 +76,7 @@ namespace CryptoExchange.Net.UnitTests
             var requestDefinition1 = new RequestDefinition(endpoint1, HttpMethod.Get);
             var requestDefinition2 = new RequestDefinition(endpoint2, HttpMethod.Get);
 
-            RateLimitEvent evnt = null;
+            RateLimitEvent? evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
             var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, null, default);
@@ -252,15 +116,15 @@ namespace CryptoExchange.Net.UnitTests
         {
             var rateLimiter = new RateLimitGate("Test");
             rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerEndpoint, new ExactPathFilter("/sapi/test"), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
-            
+
             var requestDefinition = new RequestDefinition(endpoint, HttpMethod.Get);
 
-            RateLimitEvent evnt = null;
+            RateLimitEvent? evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
                 var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, null, default);
-                bool expected = i == 1 ? (expectLimited ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
+                bool expected = i == 1 ? expectLimited ? evnt?.DelayTime > TimeSpan.Zero : evnt == null : evnt == null;
                 Assert.That(expected);
             }
         }
@@ -275,12 +139,12 @@ namespace CryptoExchange.Net.UnitTests
             rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerEndpoint, new ExactPathsFilter(new[] { "/sapi/test", "/sapi/test2" }), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
             var requestDefinition = new RequestDefinition(endpoint, HttpMethod.Get);
 
-            RateLimitEvent evnt = null;
+            RateLimitEvent? evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
                 var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, null, default);
-                bool expected = i == 1 ? (expectLimited ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
+                bool expected = i == 1 ? expectLimited ? evnt?.DelayTime > TimeSpan.Zero : evnt == null : evnt == null;
                 Assert.That(expected);
             }
         }
@@ -299,7 +163,7 @@ namespace CryptoExchange.Net.UnitTests
             var requestDefinition1 = new RequestDefinition(endpoint1, HttpMethod.Get) { Authenticated = key1 != null };
             var requestDefinition2 = new RequestDefinition(endpoint2, HttpMethod.Get) { Authenticated = key2 != null };
 
-            RateLimitEvent evnt = null;
+            RateLimitEvent? evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
             var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", key1, 1, RateLimitingBehaviour.Wait, null, default);
@@ -318,7 +182,7 @@ namespace CryptoExchange.Net.UnitTests
             var requestDefinition1 = new RequestDefinition(endpoint1, HttpMethod.Get);
             var requestDefinition2 = new RequestDefinition(endpoint2, HttpMethod.Get) { Authenticated = true };
 
-            RateLimitEvent evnt = null;
+            RateLimitEvent? evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
             var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, null, default);
@@ -338,7 +202,7 @@ namespace CryptoExchange.Net.UnitTests
             var requestDefinition1 = new RequestDefinition(endpoint1, HttpMethod.Get);
             var requestDefinition2 = new RequestDefinition(endpoint2, HttpMethod.Get) { Authenticated = true };
 
-            RateLimitEvent evnt = null;
+            RateLimitEvent? evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
             var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, host1, "123", 1, RateLimitingBehaviour.Wait, null, default);
@@ -355,7 +219,7 @@ namespace CryptoExchange.Net.UnitTests
             var rateLimiter = new RateLimitGate("Test");
             rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, new LimitItemTypeFilter(RateLimitItemType.Connection), 1, TimeSpan.FromSeconds(0.1), RateLimitWindowType.Fixed));
 
-            RateLimitEvent evnt = null;
+            RateLimitEvent? evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
             var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), host1, "123", 1, RateLimitingBehaviour.Wait, null, default);
@@ -370,7 +234,7 @@ namespace CryptoExchange.Net.UnitTests
             var rateLimiter = new RateLimitGate("Test");
             rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, new LimitItemTypeFilter(RateLimitItemType.Connection), 1, TimeSpan.FromSeconds(10), RateLimitWindowType.Fixed));
 
-            RateLimitEvent evnt = null;
+            RateLimitEvent? evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             var ct = new CancellationTokenSource(TimeSpan.FromSeconds(0.2));
 
@@ -378,5 +242,84 @@ namespace CryptoExchange.Net.UnitTests
             var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), "https://test.com", "123", 1, RateLimitingBehaviour.Wait, null, ct.Token);
             Assert.That(result2.Error, Is.TypeOf<CancellationRequestedError>());
         }
+
+        [Test]
+        public async Task RateLimiterReset_Should_AllowNextRequestForSameDefinition()
+        {
+            // arrange
+            var rateLimiter = new RateLimitGate("Test");
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerConnection, new LimitItemTypeFilter(RateLimitItemType.Request), 1, TimeSpan.FromSeconds(10), RateLimitWindowType.Fixed));
+
+            var definition = new RequestDefinition("1", HttpMethod.Get) { ConnectionId = 1 };
+
+            RateLimitEvent? evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
+            var ct = new CancellationTokenSource(TimeSpan.FromSeconds(0.2));
+
+            // act
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition, "https://test.com", null, 1, RateLimitingBehaviour.Fail, null, ct.Token);
+            await rateLimiter.ResetAsync(RateLimitItemType.Request, definition, "https://test.com", null, null, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition, "https://test.com", null, 1, RateLimitingBehaviour.Fail, null, ct.Token);
+            
+            // assert
+            Assert.That(evnt, Is.Null);
+        }
+
+        [Test]
+        public async Task RateLimiterReset_Should_NotAllowNextRequestForDifferentDefinition()
+        {
+            // arrange
+            var rateLimiter = new RateLimitGate("Test");
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerConnection, new LimitItemTypeFilter(RateLimitItemType.Request), 1, TimeSpan.FromSeconds(10), RateLimitWindowType.Fixed));
+
+            var definition1 = new RequestDefinition("1", HttpMethod.Get) { ConnectionId = 1 };
+            var definition2 = new RequestDefinition("2", HttpMethod.Get) { ConnectionId = 2 };
+
+            RateLimitEvent? evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
+
+            // act
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition1, "https://test.com", null, 1, RateLimitingBehaviour.Fail, null, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition2, "https://test.com", null, 1, RateLimitingBehaviour.Fail, null, default);
+            await rateLimiter.ResetAsync(RateLimitItemType.Request, definition1, "https://test.com", null, null, default);
+            var result3 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition2, "https://test.com", null, 1, RateLimitingBehaviour.Fail, null, default);
+            
+            // assert
+            Assert.That(evnt, Is.Not.Null);
+        }
+
+        [TestCase(null, null, true)]
+        [TestCase("Group1", null, false)]
+        [TestCase(null, "Group2", false)]
+        [TestCase("Group1", "Group2", false)]
+        [TestCase("Group3", "Group3", true)]
+        public async Task RateLimiterWithDifferentGroups_Should_LimitPerGroup(string? group1, string? group2, bool expectLimited)
+        {
+            // arrange
+            var data = JsonSerializer.Serialize(new TestObject { });
+            var client1 = new TestRestClient(x =>
+            {
+                x.RateLimitGroup = group1;
+            });
+            client1.ApiClient1.SetNextResponse(data, System.Net.HttpStatusCode.OK);
+            var client2 = new TestRestClient(x =>
+            {
+                x.RateLimitGroup = group2;
+            });
+            client2.ApiClient1.SetNextResponse(data, System.Net.HttpStatusCode.OK);
+
+            var rateLimiter = new RateLimitGate("Test");
+            rateLimiter.AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, new LimitItemTypeFilter(RateLimitItemType.Request), 1, TimeSpan.FromSeconds(2), RateLimitWindowType.Fixed));
+
+            RateLimitEvent? evnt = null;
+            rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
+
+            // act
+            var result1 = await client1.ApiClient1.GetResponseAsync<TestObject>(rateLimitGate: rateLimiter);
+            var result2 = await client2.ApiClient1.GetResponseAsync<TestObject>(rateLimitGate: rateLimiter);
+
+            // assert
+            Assert.That(evnt != null, Is.EqualTo(expectLimited));
+        }
     }
 }

CryptoExchange.Net.UnitTests/SharedQuantityTests.cs

@@ -0,0 +1,632 @@
+using CryptoExchange.Net.SharedApis;
+using NUnit.Framework;
+
+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));
+        }
+    }
+}

CryptoExchange.Net.UnitTests/SharedSymbolTests.cs

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

CryptoExchange.Net.UnitTests/SocketClientTests.cs

@@ -1,234 +0,0 @@
-//using CryptoExchange.Net.Objects;
-//using CryptoExchange.Net.Objects.Sockets;
-//using CryptoExchange.Net.Sockets;
-//using CryptoExchange.Net.Testing.Implementations;
-//using CryptoExchange.Net.UnitTests.TestImplementations;
-//using CryptoExchange.Net.UnitTests.TestImplementations.Sockets;
-//using Microsoft.Extensions.Logging;
-//using Moq;
-//using NUnit.Framework;
-//using NUnit.Framework.Legacy;
-//using System;
-//using System.Collections.Generic;
-//using System.Net.Sockets;
-//using System.Text.Json;
-//using System.Threading;
-//using System.Threading.Tasks;
-
-//namespace CryptoExchange.Net.UnitTests
-//{
-//    [TestFixture]
-//    public class SocketClientTests
-//    {
-//        [TestCase]
-//        public void SettingOptions_Should_ResultInOptionsSet()
-//        {
-//            //arrange
-//            //act
-//            var client = new TestSocketClient(options =>
-//            {
-//                options.SubOptions.ApiCredentials = new Authentication.ApiCredentials("1", "2");
-//                options.SubOptions.MaxSocketConnections = 1;
-//            });
-
-//            //assert
-//            ClassicAssert.NotNull(client.SubClient.ApiOptions.ApiCredentials);
-//            Assert.That(1 == client.SubClient.ApiOptions.MaxSocketConnections);
-//        }
-
-//        [TestCase(true)]
-//        [TestCase(false)]
-//        public void ConnectSocket_Should_ReturnConnectionResult(bool canConnect)
-//        {
-//            //arrange
-//            var client = new TestSocketClient();
-//            var socket = client.CreateSocket();
-//            socket.CanConnect = canConnect;
-
-//            //act
-//            var connectResult = client.SubClient.ConnectSocketSub(
-//                new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, ""));
-
-//            //assert
-//            Assert.That(connectResult.Success == canConnect);
-//        }
-
-//        [TestCase]
-//        public void SocketMessages_Should_BeProcessedInDataHandlers()
-//        {
-//            // arrange
-//            var client = new TestSocketClient(options => {
-//                options.ReconnectInterval = TimeSpan.Zero;
-//            });
-//            var socket = client.CreateSocket();
-//            socket.CanConnect = true;
-//            var sub = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
-//            var rstEvent = new ManualResetEvent(false);
-//            Dictionary<string, string> result = null;
-
-//            client.SubClient.ConnectSocketSub(sub);
-
-//            var subObj = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) =>
-//            {
-//                result = messageEvent.Data;
-//                rstEvent.Set();
-//            });
-//            sub.AddSubscription(subObj);
-
-//            // act
-//            socket.InvokeMessage("{\"property\": \"123\", \"action\": \"update\", \"topic\": \"topic\"}");
-//            rstEvent.WaitOne(1000);
-
-//            // assert
-//            Assert.That(result["property"] == "123");
-//        }
-
-//        [TestCase(false)]
-//        [TestCase(true)]
-//        public void SocketMessages_Should_ContainOriginalDataIfEnabled(bool enabled)
-//        {
-//            // arrange
-//            var client = new TestSocketClient(options =>
-//            {
-//                options.ReconnectInterval = TimeSpan.Zero;
-//                options.SubOptions.OutputOriginalData = enabled;
-//            });
-//            var socket = client.CreateSocket();
-//            socket.CanConnect = true;
-//            var sub = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
-//            var rstEvent = new ManualResetEvent(false);
-//            string original = null;
-
-//            client.SubClient.ConnectSocketSub(sub);
-//            var subObj = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) =>
-//            {
-//                original = messageEvent.OriginalData;
-//                rstEvent.Set();
-//            });
-//            sub.AddSubscription(subObj);
-//            var msgToSend = JsonSerializer.Serialize(new { topic = "topic", action = "update", property = "123" });
-
-//            // act
-//            socket.InvokeMessage(msgToSend);
-//            rstEvent.WaitOne(1000);
-
-//            // assert
-//            Assert.That(original == (enabled ? msgToSend : null));
-//        }
-
-//        [TestCase()]
-//        public void UnsubscribingStream_Should_CloseTheSocket()
-//        {
-//            // arrange
-//            var client = new TestSocketClient(options =>
-//            {
-//                options.ReconnectInterval = TimeSpan.Zero;
-//            });
-//            var socket = client.CreateSocket();
-//            socket.CanConnect = true;
-//            var sub = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
-//            client.SubClient.ConnectSocketSub(sub);
-
-//            var subscription = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
-//            var ups = new UpdateSubscription(sub, subscription);
-//            sub.AddSubscription(subscription);
-
-//            // act
-//            client.UnsubscribeAsync(ups).Wait();
-
-//            // assert
-//            Assert.That(socket.Connected == false);
-//        }
-
-//        [TestCase()]
-//        public void UnsubscribingAll_Should_CloseAllSockets()
-//        {
-//            // arrange
-//            var client = new TestSocketClient(options => { options.ReconnectInterval = TimeSpan.Zero; });
-//            var socket1 = client.CreateSocket();
-//            var socket2 = client.CreateSocket();
-//            socket1.CanConnect = true;
-//            socket2.CanConnect = true;
-//            var sub1 = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket1), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
-//            var sub2 = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket2), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
-//            client.SubClient.ConnectSocketSub(sub1);
-//            client.SubClient.ConnectSocketSub(sub2);
-//            var subscription1 = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
-//            var subscription2 = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
-
-//            sub1.AddSubscription(subscription1);
-//            sub2.AddSubscription(subscription2);
-//            var ups1 = new UpdateSubscription(sub1, subscription1);
-//            var ups2 = new UpdateSubscription(sub2, subscription2);
-
-//            // act
-//            client.UnsubscribeAllAsync().Wait();
-
-//            // assert
-//            Assert.That(socket1.Connected == false);
-//            Assert.That(socket2.Connected == false);
-//        }
-
-//        [TestCase()]
-//        public void FailingToConnectSocket_Should_ReturnError()
-//        {
-//            // arrange
-//            var client = new TestSocketClient(options => { options.ReconnectInterval = TimeSpan.Zero; });
-//            var socket = client.CreateSocket();
-//            socket.CanConnect = false;
-//            var sub1 = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
-
-//            // act
-//            var connectResult = client.SubClient.ConnectSocketSub(sub1);
-
-//            // assert
-//            ClassicAssert.IsFalse(connectResult.Success);
-//        }
-
-//        [TestCase()]
-//        public async Task ErrorResponse_ShouldNot_ConfirmSubscription()
-//        {
-//            // arrange
-//            var channel = "trade_btcusd";
-//            var client = new TestSocketClient(opt =>
-//            {
-//                opt.OutputOriginalData = true;
-//                opt.SocketSubscriptionsCombineTarget = 1;
-//            });
-//            var socket = client.CreateSocket();
-//            socket.CanConnect = true;
-//            client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, ""));
-
-//            // act
-//            var sub = client.SubClient.SubscribeToSomethingAsync(channel, onUpdate => {}, ct: default);
-//            socket.InvokeMessage(JsonSerializer.Serialize(new { channel, action = "subscribe", status = "error" }));
-//            await sub;
-
-//            // assert
-//            ClassicAssert.IsTrue(client.SubClient.TestSubscription.Status != SubscriptionStatus.Subscribed);
-//        }
-
-//        [TestCase()]
-//        public async Task SuccessResponse_Should_ConfirmSubscription()
-//        {
-//            // arrange
-//            var channel = "trade_btcusd";
-//            var client = new TestSocketClient(opt =>
-//            {
-//                opt.OutputOriginalData = true;
-//                opt.SocketSubscriptionsCombineTarget = 1;
-//            });
-//            var socket = client.CreateSocket();
-//            socket.CanConnect = true;
-//            client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, ""));
-
-//            // act
-//            var sub = client.SubClient.SubscribeToSomethingAsync(channel, onUpdate => {}, ct: default);
-//            socket.InvokeMessage(JsonSerializer.Serialize(new { channel, action = "subscribe", status = "confirmed" }));
-//            await sub;
-
-//            // assert
-//            Assert.That(client.SubClient.TestSubscription.Status == SubscriptionStatus.Subscribed);
-//        }
-//    }
-//}

CryptoExchange.Net.UnitTests/SocketRoutingTests/QueryRouterTests.cs

@@ -0,0 +1,235 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Sockets.Default;
+using CryptoExchange.Net.Sockets.Default.Routing;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.UnitTests.SocketRoutingTests
+{
+    [TestFixture]
+    public class QueryRouterTests
+    {
+        [Test]
+        public void BuildFromRoutes_Should_GroupRoutesByTypeIdentifier_AndSetDeserializationType()
+        {
+            // arrange
+            var routes = new MessageRoute[]
+            {
+                MessageRoute<string>.CreateWithoutTopicFilter("type1", (_, _, _, _) => null),
+                MessageRoute<string>.CreateWithTopicFilter("type1", "topic1", (_, _, _, _) => null),
+                MessageRoute<int>.CreateWithTopicFilter("type2", "topic2", (_, _, _, _) => null)
+            };
+
+            var router = new QueryRouter(routes);
+
+            // act
+            var type1Routes = router.GetRoutes("type1");
+            var type2Routes = router.GetRoutes("type2");
+            var missingRoutes = router.GetRoutes("missing");
+
+            // assert
+            Assert.That(type1Routes, Is.Not.Null);
+            Assert.That(type2Routes, Is.Not.Null);
+            Assert.That(missingRoutes, Is.Null);
+
+            Assert.That(type1Routes, Is.TypeOf<QueryRouteCollection>());
+            Assert.That(type2Routes, Is.TypeOf<QueryRouteCollection>());
+            Assert.That(type1Routes!.DeserializationType, Is.EqualTo(typeof(string)));
+            Assert.That(type2Routes!.DeserializationType, Is.EqualTo(typeof(int)));
+        }
+
+        [Test]
+        public void AddRoute_Should_SetMultipleReaders_WhenAnyRouteAllowsMultipleReaders()
+        {
+            // arrange
+            var collection = new QueryRouteCollection(typeof(string));
+
+            // act
+            collection.AddRoute(null, MessageRoute<string>.CreateWithoutTopicFilter("type", (_, _, _, _) => null));
+            var beforeMultipleReaders = collection.MultipleReaders;
+
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) => null, true));
+            var afterMultipleReaders = collection.MultipleReaders;
+
+            // assert
+            Assert.That(beforeMultipleReaders, Is.False);
+            Assert.That(afterMultipleReaders, Is.True);
+        }
+
+        [Test]
+        public void Handle_Should_InvokeRoutesWithoutTopicFilter_WhenTopicFilterIsNull()
+        {
+            // arrange
+            var calls = new List<string>();
+            var collection = new QueryRouteCollection(typeof(string));
+            collection.AddRoute(null, MessageRoute<string>.CreateWithoutTopicFilter("type", (_, _, _, _) =>
+            {
+                calls.Add("no-topic");
+                return null;
+            }));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) =>
+            {
+                calls.Add("topic");
+                return null;
+            }));
+            collection.Build();
+
+            // act
+            var handled = collection.Handle(null, null!, DateTime.UtcNow, "original", "data", out var result);
+
+            // assert
+            Assert.That(handled, Is.True);
+            Assert.That(result, Is.Null);
+            Assert.That(calls, Is.EqualTo(new[] { "no-topic" }));
+        }
+
+        [Test]
+        public void Handle_Should_ReturnFalse_WhenNoRoutesMatch()
+        {
+            // arrange
+            var collection = new QueryRouteCollection(typeof(string));
+            collection.AddRoute("other-topic", MessageRoute<string>.CreateWithTopicFilter("type", "other-topic", (_, _, _, _) => null));
+            collection.Build();
+
+            // act
+            var handled = collection.Handle("topic", null!, DateTime.UtcNow, "original", "data", out var result);
+
+            // assert
+            Assert.That(handled, Is.False);
+            Assert.That(result, Is.Null);
+        }
+
+        [Test]
+        public void Handle_Should_InvokeRoutesWithoutTopicFilter_AndMatchingTopicRoutes()
+        {
+            // arrange
+            var calls = new List<string>();
+            var collection = new QueryRouteCollection(typeof(string));
+            collection.AddRoute(null, MessageRoute<string>.CreateWithoutTopicFilter("type", (_, _, _, _) =>
+            {
+                calls.Add("no-topic");
+                return null;
+            }));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) =>
+            {
+                calls.Add("topic");
+                return null;
+            }));
+            collection.Build();
+
+            // act
+            var handled = collection.Handle("topic", null!, DateTime.UtcNow, "original", "data", out var result);
+
+            // assert
+            Assert.That(handled, Is.True);
+            Assert.That(result, Is.Null);
+            Assert.That(calls, Is.EqualTo(new[] { "no-topic", "topic" }));
+        }
+
+        [Test]
+        public void Handle_Should_StopAfterFirstNonNullMatchingResult_WhenMultipleReadersIsFalse()
+        {
+            // arrange
+            var calls = new List<string>();
+            var expectedResult = CallResult.SuccessResult;
+            var collection = new QueryRouteCollection(typeof(string));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) =>
+            {
+                calls.Add("first");
+                return expectedResult;
+            }));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) =>
+            {
+                calls.Add("second");
+                return new CallResult(null);
+            }));
+            collection.Build();
+
+            // act
+            var handled = collection.Handle("topic", null!, DateTime.UtcNow, "original", "data", out var result);
+
+            // assert
+            Assert.That(handled, Is.True);
+            Assert.That(result, Is.SameAs(expectedResult));
+            Assert.That(calls, Is.EqualTo(new[] { "first" }));
+        }
+
+        [Test]
+        public void Handle_Should_ContinueAfterNonNullMatchingResult_WhenMultipleReadersIsTrue()
+        {
+            // arrange
+            var calls = new List<string>();
+            var expectedResult = CallResult.SuccessResult;
+            var collection = new QueryRouteCollection(typeof(string));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) =>
+            {
+                calls.Add("first");
+                return expectedResult;
+            }, true));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) =>
+            {
+                calls.Add("second");
+                return new CallResult(null);
+            }));
+            collection.Build();
+
+            // act
+            var handled = collection.Handle("topic", null!, DateTime.UtcNow, "original", "data", out var result);
+
+            // assert
+            Assert.That(handled, Is.True);
+            Assert.That(result, Is.SameAs(expectedResult));
+            Assert.That(calls, Is.EqualTo(new[] { "first", "second" }));
+        }
+
+        [Test]
+        public void Handle_Should_ContinueUntilNonNullResult_WhenEarlierMatchingRoutesReturnNull()
+        {
+            // arrange
+            var calls = new List<string>();
+            var expectedResult = CallResult.SuccessResult;
+            var collection = new QueryRouteCollection(typeof(string));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) =>
+            {
+                calls.Add("first");
+                return null;
+            }));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) =>
+            {
+                calls.Add("second");
+                return expectedResult;
+            }));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) =>
+            {
+                calls.Add("third");
+                return new CallResult(null);
+            }));
+            collection.Build();
+
+            // act
+            var handled = collection.Handle("topic", null!, DateTime.UtcNow, "original", "data", out var result);
+
+            // assert
+            Assert.That(handled, Is.True);
+            Assert.That(result, Is.SameAs(expectedResult));
+            Assert.That(calls, Is.EqualTo(new[] { "first", "second" }));
+        }
+
+        [Test]
+        public void Handle_Should_ReturnHandledTrue_WhenMatchingRoutesReturnNull()
+        {
+            // arrange
+            var collection = new QueryRouteCollection(typeof(string));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) => null));
+            collection.Build();
+
+            // act
+            var handled = collection.Handle("topic", null!, DateTime.UtcNow, "original", "data", out var result);
+
+            // assert
+            Assert.That(handled, Is.True);
+            Assert.That(result, Is.Null);
+        }
+    }
+}

CryptoExchange.Net.UnitTests/SocketRoutingTests/RoutingTableTests.cs

@@ -0,0 +1,167 @@
+using CryptoExchange.Net.Sockets.Default;
+using CryptoExchange.Net.Sockets.Default.Routing;
+using CryptoExchange.Net.Sockets.Interfaces;
+using NUnit.Framework;
+using System;
+using System.Linq;
+
+namespace CryptoExchange.Net.UnitTests.SocketRoutingTests
+{
+    [TestFixture]
+    public class RoutingTableTests
+    {
+        [Test]
+        public void Update_Should_CreateEntriesPerTypeIdentifier_WithCorrectDeserializationTypeAndHandlers()
+        {
+            // arrange
+            var processor1 = new TestMessageProcessor(
+                1,
+                MessageRouter.Create(
+                    MessageRoute<string>.CreateWithoutTopicFilter("type1", (_, _, _, _) => null),
+                    MessageRoute<string>.CreateWithTopicFilter("type1", "topic1", (_, _, _, _) => null)));
+
+            var processor2 = new TestMessageProcessor(
+                2,
+                MessageRouter.Create(
+                    MessageRoute<int>.CreateWithTopicFilter("type2", "topic2", (_, _, _, _) => null)));
+
+            var table = new RoutingTable();
+
+            // act
+            table.Update(new IMessageProcessor[] { processor1, processor2 });
+
+            var type1Entry = table.GetRouteTableEntry("type1");
+            var type2Entry = table.GetRouteTableEntry("type2");
+            var missingEntry = table.GetRouteTableEntry("missing");
+
+            // assert
+            Assert.That(type1Entry, Is.Not.Null);
+            Assert.That(type2Entry, Is.Not.Null);
+            Assert.That(missingEntry, Is.Null);
+
+            Assert.That(type1Entry!.DeserializationType, Is.EqualTo(typeof(string)));
+            Assert.That(type1Entry.IsStringOutput, Is.True);
+            Assert.That(type1Entry.Handlers, Has.Count.EqualTo(1));
+            Assert.That(type1Entry.Handlers.Single(), Is.SameAs(processor1));
+
+            Assert.That(type2Entry!.DeserializationType, Is.EqualTo(typeof(int)));
+            Assert.That(type2Entry.IsStringOutput, Is.False);
+            Assert.That(type2Entry.Handlers, Has.Count.EqualTo(1));
+            Assert.That(type2Entry.Handlers.Single(), Is.SameAs(processor2));
+        }
+
+        [Test]
+        public void Update_Should_AddMultipleProcessors_ForSameTypeIdentifier()
+        {
+            // arrange
+            var processor1 = new TestMessageProcessor(
+                1,
+                MessageRouter.Create(
+                    MessageRoute<string>.CreateWithoutTopicFilter("type1", (_, _, _, _) => null)));
+
+            var processor2 = new TestMessageProcessor(
+                2,
+                MessageRouter.Create(
+                    MessageRoute<string>.CreateWithTopicFilter("type1", "topic1", (_, _, _, _) => null)));
+
+            var table = new RoutingTable();
+
+            // act
+            table.Update(new IMessageProcessor[] { processor1, processor2 });
+            var entry = table.GetRouteTableEntry("type1");
+
+            // assert
+            Assert.That(entry, Is.Not.Null);
+            Assert.That(entry!.DeserializationType, Is.EqualTo(typeof(string)));
+            Assert.That(entry.Handlers, Has.Count.EqualTo(2));
+            Assert.That(entry.Handlers, Does.Contain(processor1));
+            Assert.That(entry.Handlers, Does.Contain(processor2));
+        }
+
+        [Test]
+        public void Update_Should_ReplacePreviousEntries()
+        {
+            // arrange
+            var initialProcessor = new TestMessageProcessor(
+                1,
+                MessageRouter.Create(
+                    MessageRoute<string>.CreateWithoutTopicFilter("type1", (_, _, _, _) => null)));
+
+            var replacementProcessor = new TestMessageProcessor(
+                2,
+                MessageRouter.Create(
+                    MessageRoute<int>.CreateWithoutTopicFilter("type2", (_, _, _, _) => null)));
+
+            var table = new RoutingTable();
+            table.Update(new IMessageProcessor[] { initialProcessor });
+
+            // act
+            table.Update(new IMessageProcessor[] { replacementProcessor });
+
+            var oldEntry = table.GetRouteTableEntry("type1");
+            var newEntry = table.GetRouteTableEntry("type2");
+
+            // assert
+            Assert.That(oldEntry, Is.Null);
+            Assert.That(newEntry, Is.Not.Null);
+            Assert.That(newEntry!.DeserializationType, Is.EqualTo(typeof(int)));
+            Assert.That(newEntry.Handlers, Has.Count.EqualTo(1));
+            Assert.That(newEntry.Handlers.Single(), Is.SameAs(replacementProcessor));
+        }
+
+        [Test]
+        public void Update_WithEmptyProcessors_Should_ClearEntries()
+        {
+            // arrange
+            var processor = new TestMessageProcessor(
+                1,
+                MessageRouter.Create(
+                    MessageRoute<string>.CreateWithoutTopicFilter("type1", (_, _, _, _) => null)));
+
+            var table = new RoutingTable();
+            table.Update(new IMessageProcessor[] { processor });
+
+            // act
+            table.Update(Array.Empty<IMessageProcessor>());
+
+            // assert
+            Assert.That(table.GetRouteTableEntry("type1"), Is.Null);
+        }
+
+        [Test]
+        public void TypeRoutingCollection_Should_SetIsStringOutput_BasedOnDeserializationType()
+        {
+            // arrange & act
+            var stringCollection = new TypeRoutingCollection(typeof(string));
+            var intCollection = new TypeRoutingCollection(typeof(int));
+
+            // assert
+            Assert.That(stringCollection.IsStringOutput, Is.True);
+            Assert.That(stringCollection.DeserializationType, Is.EqualTo(typeof(string)));
+            Assert.That(stringCollection.Handlers, Is.Empty);
+
+            Assert.That(intCollection.IsStringOutput, Is.False);
+            Assert.That(intCollection.DeserializationType, Is.EqualTo(typeof(int)));
+            Assert.That(intCollection.Handlers, Is.Empty);
+        }
+
+        private sealed class TestMessageProcessor : IMessageProcessor
+        {
+            public int Id { get; }
+            public MessageRouter MessageRouter { get; }
+
+            public TestMessageProcessor(int id, MessageRouter messageRouter)
+            {
+                Id = id;
+                MessageRouter = messageRouter;
+            }
+
+            public event Action? OnMessageRouterUpdated;
+
+            public bool Handle(string typeIdentifier, string? topicFilter, SocketConnection socketConnection, DateTime receiveTime, string? originalData, object result)
+            {
+                return true;
+            }
+        }
+    }
+}

CryptoExchange.Net.UnitTests/SocketRoutingTests/SubscriptionRouterTests.cs

@@ -0,0 +1,160 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Sockets.Default.Routing;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.UnitTests.SocketRoutingTests
+{
+    [TestFixture]
+    public class SubscriptionRouterTests
+    {
+        [Test]
+        public void BuildFromRoutes_Should_GroupRoutesByTypeIdentifier_AndSetDeserializationType()
+        {
+            // arrange
+            var routes = new MessageRoute[]
+            {
+                MessageRoute<string>.CreateWithoutTopicFilter("type1", (_, _, _, _) => null),
+                MessageRoute<string>.CreateWithTopicFilter("type1", "topic1", (_, _, _, _) => null),
+                MessageRoute<int>.CreateWithTopicFilter("type2", "topic2", (_, _, _, _) => null)
+            };
+
+            var router = new SubscriptionRouter(routes);
+
+            // act
+            var type1Routes = router.GetRoutes("type1");
+            var type2Routes = router.GetRoutes("type2");
+            var missingRoutes = router.GetRoutes("missing");
+
+            // assert
+            Assert.That(type1Routes, Is.Not.Null);
+            Assert.That(type2Routes, Is.Not.Null);
+            Assert.That(missingRoutes, Is.Null);
+
+            Assert.That(type1Routes, Is.TypeOf<SubscriptionRouteCollection>());
+            Assert.That(type2Routes, Is.TypeOf<SubscriptionRouteCollection>());
+            Assert.That(type1Routes!.DeserializationType, Is.EqualTo(typeof(string)));
+            Assert.That(type2Routes!.DeserializationType, Is.EqualTo(typeof(int)));
+        }
+
+        [Test]
+        public void Handle_Should_InvokeRoutesWithoutTopicFilter_WhenTopicFilterIsNull()
+        {
+            // arrange
+            var calls = new List<string>();
+            var collection = new SubscriptionRouteCollection(typeof(string));
+            collection.AddRoute(null, MessageRoute<string>.CreateWithoutTopicFilter("type", (_, _, _, _) =>
+            {
+                calls.Add("no-topic");
+                return null;
+            }));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) =>
+            {
+                calls.Add("topic");
+                return null;
+            }));
+            collection.Build();
+
+            // act
+            var handled = collection.Handle(null, null!, DateTime.UtcNow, "original", "data", out var result);
+
+            // assert
+            Assert.That(handled, Is.True);
+            Assert.That(result, Is.SameAs(CallResult.SuccessResult));
+            Assert.That(calls, Is.EqualTo(new[] { "no-topic" }));
+        }
+
+        [Test]
+        public void Handle_Should_ReturnFalse_WhenNoRoutesMatch()
+        {
+            // arrange
+            var collection = new SubscriptionRouteCollection(typeof(string));
+            collection.AddRoute("other-topic", MessageRoute<string>.CreateWithTopicFilter("type", "other-topic", (_, _, _, _) => null));
+            collection.Build();
+
+            // act
+            var handled = collection.Handle("topic", null!, DateTime.UtcNow, "original", "data", out var result);
+
+            // assert
+            Assert.That(handled, Is.False);
+            Assert.That(result, Is.SameAs(CallResult.SuccessResult));
+        }
+
+        [Test]
+        public void Handle_Should_InvokeRoutesWithoutTopicFilter_AndMatchingTopicRoutes()
+        {
+            // arrange
+            var calls = new List<string>();
+            var collection = new SubscriptionRouteCollection(typeof(string));
+            collection.AddRoute(null, MessageRoute<string>.CreateWithoutTopicFilter("type", (_, _, _, _) =>
+            {
+                calls.Add("no-topic");
+                return null;
+            }));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) =>
+            {
+                calls.Add("topic");
+                return null;
+            }));
+            collection.Build();
+
+            // act
+            var handled = collection.Handle("topic", null!, DateTime.UtcNow, "original", "data", out var result);
+
+            // assert
+            Assert.That(handled, Is.True);
+            Assert.That(result, Is.SameAs(CallResult.SuccessResult));
+            Assert.That(calls, Is.EqualTo(new[] { "no-topic", "topic" }));
+        }
+
+        [Test]
+        public void Handle_Should_InvokeAllMatchingTopicRoutes()
+        {
+            // arrange
+            var calls = new List<string>();
+            var collection = new SubscriptionRouteCollection(typeof(string));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) =>
+            {
+                calls.Add("first");
+                return CallResult.SuccessResult;
+            }));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) =>
+            {
+                calls.Add("second");
+                return null;
+            }));
+            collection.Build();
+
+            // act
+            var handled = collection.Handle("topic", null!, DateTime.UtcNow, "original", "data", out var result);
+
+            // assert
+            Assert.That(handled, Is.True);
+            Assert.That(result, Is.SameAs(CallResult.SuccessResult));
+            Assert.That(calls, Is.EqualTo(new[] { "first", "second" }));
+        }
+
+        [Test]
+        public void Handle_Should_NotInvokeTopicRoutes_WhenTopicFilterIsNull()
+        {
+            // arrange
+            var calls = new List<string>();
+            var collection = new SubscriptionRouteCollection(typeof(string));
+            collection.AddRoute("topic", MessageRoute<string>.CreateWithTopicFilter("type", "topic", (_, _, _, _) =>
+            {
+                calls.Add("topic");
+                return null;
+            }));
+            collection.Build();
+
+            // act
+            var handled = collection.Handle(null, null!, DateTime.UtcNow, "original", "data", out var result);
+
+            // assert
+            Assert.That(handled, Is.False);
+            Assert.That(result, Is.SameAs(CallResult.SuccessResult));
+            Assert.That(calls, Is.Empty);
+        }
+    }
+}

CryptoExchange.Net.UnitTests/SystemTextJsonConverterTests.cs

@@ -1,440 +0,0 @@
-using CryptoExchange.Net.Attributes;
-using CryptoExchange.Net.Converters.SystemTextJson;
-using System.Text.Json;
-using NUnit.Framework;
-using System;
-using System.Text.Json.Serialization;
-using CryptoExchange.Net.Converters;
-using CryptoExchange.Net.SharedApis;
-
-namespace CryptoExchange.Net.UnitTests
-{
-    [TestFixture()]
-    public class SystemTextJsonConverterTests
-    {
-        [TestCase("2021-05-12")]
-        [TestCase("20210512")]
-        [TestCase("210512")]
-        [TestCase("1620777600.000")]
-        [TestCase("1620777600000")]
-        [TestCase("2021-05-12T00:00:00.000Z")]
-        [TestCase("2021-05-12T00:00:00.000000000Z")]
-        [TestCase("0.000000", true)]
-        [TestCase("0", true)]
-        [TestCase("", true)]
-        [TestCase("  ", true)]
-        public void TestDateTimeConverterString(string input, bool expectNull = false)
-        {
-            var output = JsonSerializer.Deserialize<STJTimeObject>($"{{ \"time\": \"{input}\" }}");
-            Assert.That(output.Time == (expectNull ? null: new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc)));
-        }
-
-        [TestCase(1620777600.000)]
-        [TestCase(1620777600000d)]
-        public void TestDateTimeConverterDouble(double input)
-        {
-            var output = JsonSerializer.Deserialize<STJTimeObject>($"{{ \"time\": {input} }}");
-            Assert.That(output.Time == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
-        }
-
-        [TestCase(1620777600)]
-        [TestCase(1620777600000)]
-        [TestCase(1620777600000000)]
-        [TestCase(1620777600000000000)]
-        [TestCase(0, true)]
-        public void TestDateTimeConverterLong(long input, bool expectNull = false)
-        {
-            var output = JsonSerializer.Deserialize<STJTimeObject>($"{{ \"time\": {input} }}");
-            Assert.That(output.Time == (expectNull ? null : new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc)));
-        }
-
-        [TestCase(1620777600)]
-        [TestCase(1620777600.000)]
-        public void TestDateTimeConverterFromSeconds(double input)
-        {
-            var output = DateTimeConverter.ConvertFromSeconds(input);
-            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
-        }
-
-        [Test]
-        public void TestDateTimeConverterToSeconds()
-        {
-            var output = DateTimeConverter.ConvertToSeconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
-            Assert.That(output == 1620777600);
-        }
-
-        [TestCase(1620777600000)]
-        [TestCase(1620777600000.000)]
-        public void TestDateTimeConverterFromMilliseconds(double input)
-        {
-            var output = DateTimeConverter.ConvertFromMilliseconds(input);
-            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
-        }
-
-        [Test]
-        public void TestDateTimeConverterToMilliseconds()
-        {
-            var output = DateTimeConverter.ConvertToMilliseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
-            Assert.That(output == 1620777600000);
-        }
-
-        [TestCase(1620777600000000)]
-        public void TestDateTimeConverterFromMicroseconds(long input)
-        {
-            var output = DateTimeConverter.ConvertFromMicroseconds(input);
-            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
-        }
-
-        [Test]
-        public void TestDateTimeConverterToMicroseconds()
-        {
-            var output = DateTimeConverter.ConvertToMicroseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
-            Assert.That(output == 1620777600000000);
-        }
-
-        [TestCase(1620777600000000000)]
-        public void TestDateTimeConverterFromNanoseconds(long input)
-        {
-            var output = DateTimeConverter.ConvertFromNanoseconds(input);
-            Assert.That(output == new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
-        }
-
-        [Test]
-        public void TestDateTimeConverterToNanoseconds()
-        {
-            var output = DateTimeConverter.ConvertToNanoseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
-            Assert.That(output == 1620777600000000000);
-        }
-
-        [TestCase()]
-        public void TestDateTimeConverterNull()
-        {
-            var output = JsonSerializer.Deserialize<STJTimeObject>($"{{ \"time\": null }}");
-            Assert.That(output.Time == null);
-        }
-
-        [TestCase(TestEnum.One, "1")]
-        [TestCase(TestEnum.Two, "2")]
-        [TestCase(TestEnum.Three, "three")]
-        [TestCase(TestEnum.Four, "Four")]
-        [TestCase(null, null)]
-        public void TestEnumConverterNullableGetStringTests(TestEnum? value, string expected)
-        {
-            var output = EnumConverter.GetString(value);
-            Assert.That(output == expected);
-        }
-
-        [TestCase(TestEnum.One, "1")]
-        [TestCase(TestEnum.Two, "2")]
-        [TestCase(TestEnum.Three, "three")]
-        [TestCase(TestEnum.Four, "Four")]
-        public void TestEnumConverterGetStringTests(TestEnum value, string expected)
-        {
-            var output = EnumConverter.GetString(value);
-            Assert.That(output == expected);
-        }
-
-        [TestCase("1", TestEnum.One)]
-        [TestCase("2", TestEnum.Two)]
-        [TestCase("3", TestEnum.Three)]
-        [TestCase("three", TestEnum.Three)]
-        [TestCase("Four", TestEnum.Four)]
-        [TestCase("four", TestEnum.Four)]
-        [TestCase("Four1", null)]
-        [TestCase(null, null)]
-        public void TestEnumConverterNullableDeserializeTests(string value, TestEnum? expected)
-        {
-            var val = value == null ? "null" : $"\"{value}\"";
-            var output = JsonSerializer.Deserialize<STJEnumObject>($"{{ \"Value\": {val} }}", SerializerOptions.WithConverters(new SerializationContext()));
-            Assert.That(output.Value == expected);
-        }
-
-        [TestCase("1", TestEnum.One)]
-        [TestCase("2", TestEnum.Two)]
-        [TestCase("3", TestEnum.Three)]
-        [TestCase("three", TestEnum.Three)]
-        [TestCase("Four", TestEnum.Four)]
-        [TestCase("four", TestEnum.Four)]
-        [TestCase("Four1", TestEnum.One)]
-        [TestCase(null, TestEnum.One)]
-        public void TestEnumConverterNotNullableDeserializeTests(string value, TestEnum? expected)
-        {
-            var val = value == null ? "null" : $"\"{value}\"";
-            var output = JsonSerializer.Deserialize<NotNullableSTJEnumObject>($"{{ \"Value\": {val} }}");
-            Assert.That(output.Value == expected);
-        }
-
-        [TestCase("1", TestEnum.One)]
-        [TestCase("2", TestEnum.Two)]
-        [TestCase("3", TestEnum.Three)]
-        [TestCase("three", TestEnum.Three)]
-        [TestCase("Four", TestEnum.Four)]
-        [TestCase("four", TestEnum.Four)]
-        [TestCase("Four1", null)]
-        [TestCase(null, null)]
-        public void TestEnumConverterParseStringTests(string value, TestEnum? expected)
-        {
-            var result = EnumConverter.ParseString<TestEnum>(value);
-            Assert.That(result == expected);
-        }
-
-        [TestCase("1", true)]
-        [TestCase("true", true)]
-        [TestCase("yes", true)]
-        [TestCase("y", true)]
-        [TestCase("on", true)]
-        [TestCase("-1", false)]
-        [TestCase("0", false)]
-        [TestCase("n", false)]
-        [TestCase("no", false)]
-        [TestCase("false", false)]
-        [TestCase("off", false)]
-        [TestCase("", null)]
-        public void TestBoolConverter(string value, bool? expected)
-        {
-            var val = value == null ? "null" : $"\"{value}\"";
-            var output = JsonSerializer.Deserialize<STJBoolObject>($"{{ \"Value\": {val} }}", SerializerOptions.WithConverters(new SerializationContext()));
-            Assert.That(output.Value == expected);
-        }
-
-        [TestCase("1", true)]
-        [TestCase("true", true)]
-        [TestCase("yes", true)]
-        [TestCase("y", true)]
-        [TestCase("on", true)]
-        [TestCase("-1", false)]
-        [TestCase("0", false)]
-        [TestCase("n", false)]
-        [TestCase("no", false)]
-        [TestCase("false", false)]
-        [TestCase("off", false)]
-        [TestCase("", false)]
-        public void TestBoolConverterNotNullable(string value, bool expected)
-        {
-            var val = value == null ? "null" : $"\"{value}\"";
-            var output = JsonSerializer.Deserialize<NotNullableSTJBoolObject>($"{{ \"Value\": {val} }}", SerializerOptions.WithConverters(new SerializationContext()));
-            Assert.That(output.Value == expected);
-        }
-
-        [TestCase("1", 1)]
-        [TestCase("1.1", 1.1)]
-        [TestCase("-1.1", -1.1)]
-        [TestCase(null, null)]
-        [TestCase("", null)]
-        [TestCase("null", null)]
-        [TestCase("nan", null)]
-        [TestCase("1E+2", 100)]
-        [TestCase("1E-2", 0.01)]
-        [TestCase("Infinity", 999)] // 999 is workaround for not being able to specify decimal.MinValue
-        [TestCase("-Infinity", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
-        [TestCase("80228162514264337593543950335", 999)] // 999 is workaround for not being able to specify decimal.MaxValue
-        [TestCase("-80228162514264337593543950335", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
-        public void TestDecimalConverterString(string value, decimal? expected)
-        {
-            var result = JsonSerializer.Deserialize<STJDecimalObject>("{ \"test\": \""+ value + "\"}");
-            Assert.That(result.Test, Is.EqualTo(expected == -999 ? decimal.MinValue : expected == 999 ? decimal.MaxValue: expected));
-        }
-
-        [TestCase("1", 1)]
-        [TestCase("1.1", 1.1)]
-        [TestCase("-1.1", -1.1)]
-        [TestCase("null", null)]
-        [TestCase("1E+2", 100)]
-        [TestCase("1E-2", 0.01)]
-        [TestCase("80228162514264337593543950335", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
-        public void TestDecimalConverterNumber(string value, decimal? expected)
-        {
-            var result = JsonSerializer.Deserialize<STJDecimalObject>("{ \"test\": " + value + "}");
-            Assert.That(result.Test, Is.EqualTo(expected == -999 ? decimal.MaxValue : expected));
-        }
-
-        [Test()]
-        public void TestArrayConverter()
-        {
-            var data = new Test()
-            {
-                Prop1 = 2,
-                Prop2 = null,
-                Prop3 = "123",
-                Prop3Again = "123",
-                Prop4 = null,
-                Prop5 = new Test2
-                {
-                    Prop21 = 3,
-                    Prop22 = "456"
-                },
-                Prop6 = new Test3
-                {
-                    Prop31 = 4,
-                    Prop32 = "789"
-                },
-                Prop7 = TestEnum.Two,
-                TestInternal = new Test
-                {
-                    Prop1 = 10
-                },
-                Prop8 = new Test3
-                {
-                    Prop31 = 5,
-                    Prop32 = "101"
-                },
-            };
-
-            var options = new JsonSerializerOptions()
-            {
-                TypeInfoResolver = new SerializationContext()
-            };
-            var serialized = JsonSerializer.Serialize(data);
-            var deserialized = JsonSerializer.Deserialize<Test>(serialized);
-
-            Assert.That(deserialized.Prop1, Is.EqualTo(2));
-            Assert.That(deserialized.Prop2, Is.Null);
-            Assert.That(deserialized.Prop3, Is.EqualTo("123"));
-            Assert.That(deserialized.Prop3Again, Is.EqualTo("123"));
-            Assert.That(deserialized.Prop4, Is.Null);
-            Assert.That(deserialized.Prop5.Prop21, Is.EqualTo(3));
-            Assert.That(deserialized.Prop5.Prop22, Is.EqualTo("456"));
-            Assert.That(deserialized.Prop6.Prop31, Is.EqualTo(4));
-            Assert.That(deserialized.Prop6.Prop32, Is.EqualTo("789"));
-            Assert.That(deserialized.Prop7, Is.EqualTo(TestEnum.Two));
-            Assert.That(deserialized.TestInternal.Prop1, Is.EqualTo(10));
-            Assert.That(deserialized.Prop8.Prop31, Is.EqualTo(5));
-            Assert.That(deserialized.Prop8.Prop32, Is.EqualTo("101"));
-        }
-
-        [TestCase(TradingMode.Spot, "ETH", "USDT", null)]
-        [TestCase(TradingMode.PerpetualLinear, "ETH", "USDT", null)]
-        [TestCase(TradingMode.DeliveryLinear, "ETH", "USDT", 1748432430)]
-        public void TestSharedSymbolConversion(TradingMode tradingMode, string baseAsset, string quoteAsset, int? deliverTime)
-        {
-            DateTime? time = deliverTime == null ? null : DateTimeConverter.ParseFromDouble(deliverTime.Value);
-            var symbol = new SharedSymbol(tradingMode, baseAsset, quoteAsset, time);
-
-            var serialized = JsonSerializer.Serialize(symbol);
-            var restored = JsonSerializer.Deserialize<SharedSymbol>(serialized);
-
-            Assert.That(restored.TradingMode, Is.EqualTo(symbol.TradingMode));
-            Assert.That(restored.BaseAsset, Is.EqualTo(symbol.BaseAsset));
-            Assert.That(restored.QuoteAsset, Is.EqualTo(symbol.QuoteAsset));
-            Assert.That(restored.DeliverTime, Is.EqualTo(symbol.DeliverTime));
-        }
-
-        [TestCase(0.1, null, null)]
-        [TestCase(0.1, 0.1, null)]
-        [TestCase(0.1, 0.1, 0.1)]
-        [TestCase(null, 0.1, null)]
-        [TestCase(null, 0.1, 0.1)]
-        public void TestSharedQuantityConversion(double? baseQuantity, double? quoteQuantity, double? contractQuantity)
-        {
-            var symbol = new SharedOrderQuantity((decimal?)baseQuantity, (decimal?)quoteQuantity, (decimal?)contractQuantity);
-
-            var serialized = JsonSerializer.Serialize(symbol);
-            var restored = JsonSerializer.Deserialize<SharedOrderQuantity>(serialized);
-
-            Assert.That(restored.QuantityInBaseAsset, Is.EqualTo(symbol.QuantityInBaseAsset));
-            Assert.That(restored.QuantityInQuoteAsset, Is.EqualTo(symbol.QuantityInQuoteAsset));
-            Assert.That(restored.QuantityInContracts, Is.EqualTo(symbol.QuantityInContracts));
-        }
-    }
-
-    public class STJDecimalObject
-    {
-        [JsonConverter(typeof(DecimalConverter))]
-        [JsonPropertyName("test")]
-        public decimal? Test { get; set; }
-    }
-
-    public class STJTimeObject
-    {
-        [JsonConverter(typeof(DateTimeConverter))]
-        [JsonPropertyName("time")]
-        public DateTime? Time { get; set; }
-    }
-
-    public class STJEnumObject
-    {
-        public TestEnum? Value { get; set; }
-    }
-
-    public class NotNullableSTJEnumObject
-    {
-        public TestEnum Value { get; set; }
-    }
-
-    public class STJBoolObject
-    {
-        public bool? Value { get; set; }
-    }
-
-    public class NotNullableSTJBoolObject
-    {
-        public bool Value { get; set; }
-    }
-
-    [JsonConverter(typeof(ArrayConverter<Test>))]
-    record Test
-    {
-        [ArrayProperty(0)]
-        public int Prop1 { get; set; }
-        [ArrayProperty(1)]
-        public int? Prop2 { get; set; }
-        [ArrayProperty(2)]
-        public string Prop3 { get; set; }
-        [ArrayProperty(2)]
-        public string Prop3Again { get; set; }
-        [ArrayProperty(3)]
-        public string Prop4 { get; set; }
-        [ArrayProperty(4)]
-        public Test2 Prop5 { get; set; }
-        [ArrayProperty(5)]
-        public Test3 Prop6 { get; set; }
-        [ArrayProperty(6), JsonConverter(typeof(EnumConverter<TestEnum>))]
-        public TestEnum? Prop7 { get; set; }
-        [ArrayProperty(7)]
-        public Test TestInternal { get; set; }
-        [ArrayProperty(8), JsonConversion]
-        public Test3 Prop8 { get; set; }
-    }
-
-    [JsonConverter(typeof(ArrayConverter<Test2>))]
-    record Test2
-    {
-        [ArrayProperty(0)]
-        public int Prop21 { get; set; }
-        [ArrayProperty(1)]
-        public string Prop22 { get; set; }
-    }
-
-    record Test3
-    {
-        [JsonPropertyName("prop31")]
-        public int Prop31 { get; set; }
-        [JsonPropertyName("prop32")]
-        public string Prop32 { get; set; }
-    }
-
-    [JsonConverter(typeof(EnumConverter<TestEnum>))]
-    public enum TestEnum
-    {
-        [Map("1")]
-        One,
-        [Map("2")]
-        Two,
-        [Map("three", "3")]
-        Three,
-        Four
-    }
-
-    [JsonSerializable(typeof(Test))]
-    [JsonSerializable(typeof(Test2))]
-    [JsonSerializable(typeof(Test3))]
-    [JsonSerializable(typeof(NotNullableSTJBoolObject))]
-    [JsonSerializable(typeof(STJBoolObject))]
-    [JsonSerializable(typeof(NotNullableSTJEnumObject))]
-    [JsonSerializable(typeof(STJEnumObject))]
-    [JsonSerializable(typeof(STJDecimalObject))]
-    [JsonSerializable(typeof(STJTimeObject))]
-    internal partial class SerializationContext : JsonSerializerContext
-    {
-    }
-}

CryptoExchange.Net.UnitTests/TestImplementations/TestBaseClient.cs

@@ -1,97 +0,0 @@
-using System;
-using System.IO;
-using System.Text;
-using System.Threading.Tasks;
-using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Clients;
-using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
-using CryptoExchange.Net.Converters.SystemTextJson;
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Errors;
-using CryptoExchange.Net.Objects.Options;
-using CryptoExchange.Net.SharedApis;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Abstractions;
-
-namespace CryptoExchange.Net.UnitTests
-{
-    public class TestBaseClient: BaseClient
-    {       
-        public TestSubClient SubClient { get; }
-
-        public TestBaseClient(): base(null, "Test")
-        {
-            var options = new TestClientOptions();
-            _logger = NullLogger.Instance;
-            Initialize(options);
-            SubClient = AddApiClient(new TestSubClient(options, new RestApiOptions()));
-        }
-
-        public TestBaseClient(TestClientOptions exchangeOptions) : base(null, "Test")
-        {
-            _logger = NullLogger.Instance;
-            Initialize(exchangeOptions);
-            SubClient = AddApiClient(new TestSubClient(exchangeOptions, new RestApiOptions()));
-        }
-
-        public void Log(LogLevel verbosity, string data)
-        {
-            _logger.Log(verbosity, data);
-        }
-    }
-
-    public class TestSubClient : RestApiClient
-    {
-        protected override IRestMessageHandler MessageHandler => throw new NotImplementedException();
-
-        public TestSubClient(RestExchangeOptions<TestEnvironment> options, RestApiOptions apiOptions) : base(new TraceLogger(), null, "https://localhost:123", options, apiOptions)
-        {
-        }
-
-        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;
-        }
-
-        /// <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();
-    }
-
-    public class TestAuthProvider : AuthenticationProvider
-    {
-        public override ApiCredentialsType[] SupportedCredentialTypes => [ApiCredentialsType.Hmac];
-
-        public TestAuthProvider(ApiCredentials credentials) : base(credentials)
-        {
-        }
-
-        public override void ProcessRequest(RestApiClient apiClient, RestRequestConfiguration requestConfig)
-        {
-        }
-        
-        public string GetKey() => _credentials.Key;
-        public string GetSecret() => _credentials.Secret;
-    }
-
-    public class TestEnvironment : TradeEnvironment
-    {
-        public string TestAddress { get; }
-
-        public TestEnvironment(string name, string url) : base(name)
-        {
-            TestAddress = url;
-        }
-    }
-}

CryptoExchange.Net.UnitTests/TestImplementations/TestHelpers.cs

@@ -1,49 +0,0 @@
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Reflection;
-
-namespace CryptoExchange.Net.UnitTests.TestImplementations
-{
-    public class TestHelpers
-    {
-        [ExcludeFromCodeCoverage]
-        public static bool AreEqual<T>(T self, T to, params string[] ignore) where T : class
-        {
-            if (self != null && to != null)
-            {
-                var type = self.GetType();
-                var ignoreList = new List<string>(ignore);
-                foreach (var pi in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
-                {
-                    if (ignoreList.Contains(pi.Name))
-                    {
-                        continue;
-                    }
-
-                    var selfValue = type.GetProperty(pi.Name).GetValue(self, null);
-                    var toValue = type.GetProperty(pi.Name).GetValue(to, null);
-
-                    if (pi.PropertyType.IsClass && !pi.PropertyType.Module.ScopeName.Equals("System.Private.CoreLib.dll"))
-                    {
-                        // Check of "CommonLanguageRuntimeLibrary" is needed because string is also a class
-                        if (AreEqual(selfValue, toValue, ignore))
-                        {
-                            continue;
-                        }
-
-                        return false;
-                    }
-
-                    if (selfValue != toValue && (selfValue == null || !selfValue.Equals(toValue)))
-                    {
-                        return false;
-                    }
-                }
-
-                return true;
-            }
-
-            return self == to;
-        }
-    }
-}

CryptoExchange.Net.UnitTests/TestImplementations/TestRestClient.cs

@@ -1,215 +0,0 @@
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Objects;
-using Moq;
-using System;
-using System.IO;
-using System.Net;
-using System.Net.Http;
-using System.Reflection;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using CryptoExchange.Net.Authentication;
-using System.Collections.Generic;
-using Microsoft.Extensions.Logging;
-using CryptoExchange.Net.Clients;
-using Microsoft.Extensions.Options;
-using System.Linq;
-using CryptoExchange.Net.Converters.SystemTextJson;
-using System.Text.Json.Serialization;
-using System.Net.Http.Headers;
-using CryptoExchange.Net.SharedApis;
-using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
-
-namespace CryptoExchange.Net.UnitTests.TestImplementations
-{
-    public class TestRestClient: BaseRestClient
-    {
-        public TestRestApi1Client Api1 { get; }
-        public TestRestApi2Client Api2 { get; }
-
-        public TestRestClient(Action<TestClientOptions> optionsDelegate = null)
-            : this(null, null, Options.Create(ApplyOptionsDelegate(optionsDelegate)))
-        {
-        }
-
-        public TestRestClient(HttpClient httpClient, ILoggerFactory loggerFactory, IOptions<TestClientOptions> options) : base(loggerFactory, "Test")
-        {
-            Initialize(options.Value);
-
-            Api1 = new TestRestApi1Client(options.Value);
-            Api2 = new TestRestApi2Client(options.Value);
-        }
-
-        public void SetResponse(string responseData, out IRequest requestObj)
-        {
-            var expectedBytes = Encoding.UTF8.GetBytes(responseData);
-            var responseStream = new MemoryStream();
-            responseStream.Write(expectedBytes, 0, expectedBytes.Length);
-            responseStream.Seek(0, SeekOrigin.Begin);
-
-            var response = new Mock<IResponse>();
-            response.Setup(c => c.IsSuccessStatusCode).Returns(true);
-            response.Setup(c => c.GetResponseStreamAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult((Stream)responseStream));
-            
-            var headers = new HttpRequestMessage().Headers;
-            var request = new Mock<IRequest>();
-            request.Setup(c => c.Uri).Returns(new Uri("http://www.test.com"));
-            request.Setup(c => c.GetResponseAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult(response.Object));
-            request.Setup(c => c.SetContent(It.IsAny<string>(), It.IsAny<string>())).Callback(new Action<string, string>((content, type) => { request.Setup(r => r.Content).Returns(content); }));
-            request.Setup(c => c.AddHeader(It.IsAny<string>(), It.IsAny<string>())).Callback<string, string>((key, val) => headers.Add(key, new string[] { val }));
-            request.Setup(c => c.GetHeaders()).Returns(() => headers);
-
-            var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) => 
-                { 
-                    request.Setup(a => a.Uri).Returns(uri);
-                    request.Setup(a => a.Method).Returns(method); 
-                })
-                .Returns(request.Object);
-
-            factory = Mock.Get(Api2.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) =>
-                {
-                    request.Setup(a => a.Uri).Returns(uri);
-                    request.Setup(a => a.Method).Returns(method);
-                })
-                .Returns(request.Object);
-            requestObj = request.Object;
-        }
-
-        public void SetErrorWithoutResponse(HttpStatusCode code, string message)
-        {
-            var we = new HttpRequestException();
-            typeof(HttpRequestException).GetField("_message", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(we, message);
-           
-            var request = new Mock<IRequest>();
-            request.Setup(c => c.Uri).Returns(new Uri("http://www.test.com"));
-            request.Setup(c => c.GetHeaders()).Returns(new HttpRequestMessage().Headers);
-            request.Setup(c => c.GetResponseAsync(It.IsAny<CancellationToken>())).Throws(we);
-
-            var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Returns(request.Object);
-
-
-            factory = Mock.Get(Api2.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Returns(request.Object);
-        }
-
-        public void SetErrorWithResponse(string responseData, HttpStatusCode code)
-        {
-            var expectedBytes = Encoding.UTF8.GetBytes(responseData);
-            var responseStream = new MemoryStream();
-            responseStream.Write(expectedBytes, 0, expectedBytes.Length);
-            responseStream.Seek(0, SeekOrigin.Begin);
-
-            var response = new Mock<IResponse>();
-            response.Setup(c => c.IsSuccessStatusCode).Returns(false);
-            response.Setup(c => c.GetResponseStreamAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult((Stream)responseStream));
-
-            var headers = new List<KeyValuePair<string, string[]>>();
-            var request = new Mock<IRequest>();
-            request.Setup(c => c.Uri).Returns(new Uri("http://www.test.com"));
-            request.Setup(c => c.GetResponseAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult(response.Object));
-            request.Setup(c => c.AddHeader(It.IsAny<string>(), It.IsAny<string>())).Callback<string, string>((key, val) => headers.Add(new KeyValuePair<string, string[]>(key, new string[] { val })));
-            request.Setup(c => c.GetHeaders()).Returns(new HttpRequestMessage().Headers);
-
-            var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
-                .Returns(request.Object);
-
-            factory = Mock.Get(Api2.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
-                .Returns(request.Object);
-        }
-    }
-
-    public class TestRestApi1Client : RestApiClient
-    {
-        protected override IRestMessageHandler MessageHandler { get; } = new TestRestMessageHandler();
-
-        public TestRestApi1Client(TestClientOptions options) : base(new TraceLogger(), null, "https://localhost:123", options, options.Api1Options)
-        {
-            RequestFactory = new Mock<IRequestFactory>().Object;
-        }
-
-        /// <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
-        {
-            return await SendAsync<T>("http://www.test.com", new RequestDefinition("/", HttpMethod.Get) { Weight = 0 }, null, ct);
-        }
-
-        public async Task<CallResult<T>> RequestWithParams<T>(HttpMethod method, ParameterCollection parameters, Dictionary<string, string> headers) where T : class
-        {
-            return await SendAsync<T>("http://www.test.com", new RequestDefinition("/", method) { Weight = 0 }, parameters, default, additionalHeaders: headers);
-        }
-
-        public void SetParameterPosition(HttpMethod method, HttpMethodParameterPosition position)
-        {
-            ParameterPositions[method] = position;
-        }
-
-        protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials)
-            => new TestAuthProvider(credentials);
-
-        protected override Task<WebCallResult<DateTime>> GetServerTimestampAsync()
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    public class TestRestApi2Client : RestApiClient
-    {
-        protected override IRestMessageHandler MessageHandler { get; } = new TestRestMessageHandler();
-
-        public TestRestApi2Client(TestClientOptions options) : base(new TraceLogger(), null, "https://localhost:123", options, options.Api2Options)
-        {
-            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 />
-        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode futuresType, DateTime? deliverDate = null) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
-
-        public async Task<CallResult<T>> Request<T>(CancellationToken ct = default) where T : class
-        {
-            return await SendAsync<T>("http://www.test.com", new RequestDefinition("/", HttpMethod.Get) { Weight = 0 }, null, ct);
-        }
-        
-        protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials)
-            => new TestAuthProvider(credentials);
-
-        protected override Task<WebCallResult<DateTime>> GetServerTimestampAsync()
-        {
-            throw new NotImplementedException();
-        }
-
-    }
-
-    public class TestError
-    {
-        [JsonPropertyName("errorCode")]
-        public int ErrorCode { get; set; }
-        [JsonPropertyName("errorMessage")]
-        public string ErrorMessage { get; set; }
-    }
-
-    public class ParseErrorTestRestClient: TestRestClient
-    {
-        public ParseErrorTestRestClient() { }
-
-    }
-}

CryptoExchange.Net.UnitTests/TestImplementations/TestRestMessageHandler.cs

@@ -1,29 +0,0 @@
-using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
-using CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers;
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Errors;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Net.Http.Headers;
-using System.Text;
-using System.Text.Json;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.UnitTests.TestImplementations
-{
-    internal class TestRestMessageHandler : JsonRestMessageHandler
-    {
-        private ErrorMapping _errorMapping = new ErrorMapping([]);
-        public override JsonSerializerOptions Options => new JsonSerializerOptions();
-
-        public override ValueTask<Error> ParseErrorResponse(int httpStatusCode, HttpResponseHeaders responseHeaders, Stream responseStream)
-        {
-            var errorData = JsonSerializer.Deserialize<TestError>(responseStream);
-
-            return new ValueTask<Error>(new ServerError(errorData.ErrorCode, _errorMapping.GetErrorInfo(errorData.ErrorCode.ToString(), errorData.ErrorMessage)));
-        }
-    }
-}

CryptoExchange.Net.UnitTests/TestSerializerContext.cs

@@ -1,17 +0,0 @@
-using CryptoExchange.Net.UnitTests.TestImplementations;
-using System.Collections.Generic;
-using System.Text.Json.Serialization;
-
-namespace CryptoExchange.Net.UnitTests
-{
-    [JsonSerializable(typeof(string))]
-    [JsonSerializable(typeof(int))]
-    [JsonSerializable(typeof(Dictionary<string, string>))]
-    [JsonSerializable(typeof(IDictionary<string, string>))]
-    [JsonSerializable(typeof(Dictionary<string, object>))]
-    [JsonSerializable(typeof(IDictionary<string, object>))]
-    [JsonSerializable(typeof(TestObject))]
-    internal partial class TestSerializerContext : JsonSerializerContext
-    {
-    }
-}

CryptoExchange.Net.UnitTests/UriSerializationTests.cs

@@ -0,0 +1,105 @@
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using CryptoExchange.Net;
+using CryptoExchange.Net.Objects;
+
+namespace CryptoExchange.Net.UnitTests
+{
+    internal class UriSerializationTests
+    {
+        [Test]
+        public void CreateParamString_SerializesBasicValuesCorrectly()
+        {
+            var parameters = new Dictionary<string, object>()
+            {
+                { "a", "1" },
+                { "b", 2 },
+                { "c", true }
+            };
+
+            var parameterString = parameters.CreateParamString(false, ArrayParametersSerialization.Array);
+
+            Assert.That(parameterString, Is.EqualTo("a=1&b=2&c=True"));
+        }
+
+        [Test]
+        public void CreateParamString_SerializesArrayValuesCorrectly()
+        {
+            var parameters = new Dictionary<string, object>()
+            {
+                { "a", new [] { "1", "2" } },
+            };
+
+            var parameterString = parameters.CreateParamString(false, ArrayParametersSerialization.Array);
+
+            Assert.That(parameterString, Is.EqualTo("a[]=1&a[]=2"));
+        }
+
+        [Test]
+        public void CreateParamStringEncoded_SerializesArrayValuesCorrectly()
+        {
+            var parameters = new Dictionary<string, object>()
+            {
+                { "a", new [] { "1+2", "2+3" } },
+            };
+
+            var parameterString = parameters.CreateParamString(true, ArrayParametersSerialization.Array);
+
+            Assert.That(parameterString, Is.EqualTo("a[]=1%2B2&a[]=2%2B3"));
+        }
+
+        [Test]
+        public void CreateParamString_SerializesJsonArrayValuesCorrectly()
+        {
+            var parameters = new Dictionary<string, object>()
+            {
+                { "a", new [] { "1", "2" } },
+            };
+
+            var parameterString = parameters.CreateParamString(false, ArrayParametersSerialization.JsonArray);
+
+            Assert.That(parameterString, Is.EqualTo("a=[1,2]"));
+        }
+
+        [Test]
+        public void CreateParamStringEncoded_SerializesJsonArrayValuesCorrectly()
+        {
+            var parameters = new Dictionary<string, object>()
+            {
+                { "a", new [] { "1+2", "2+3" } },
+            };
+
+            var parameterString = parameters.CreateParamString(true, ArrayParametersSerialization.JsonArray);
+
+            Assert.That(parameterString, Is.EqualTo("a=[1%2B2,2%2B3]"));
+        }
+
+        [Test]
+        public void CreateParamString_SerializesMultipleValuesArrayCorrectly()
+        {
+            var parameters = new Dictionary<string, object>()
+            {
+                { "a", new [] { "1", "2" } },
+            };
+
+            var parameterString = parameters.CreateParamString(false, ArrayParametersSerialization.MultipleValues);
+
+            Assert.That(parameterString, Is.EqualTo("a=1&a=2"));
+        }
+
+        [Test]
+        public void CreateParamStringEncoded_SerializesMultipleValuesArrayCorrectly()
+        {
+            var parameters = new Dictionary<string, object>()
+            {
+                { "a", new [] { "1+2", "2+3" } },
+            };
+
+            var parameterString = parameters.CreateParamString(true, ArrayParametersSerialization.MultipleValues);
+
+            Assert.That(parameterString, Is.EqualTo("a=1%2B2&a=2%2B3"));
+        }
+    }
+}

CryptoExchange.Net.sln

@@ -15,8 +15,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ConsoleClient", "Examples\C
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharedClients", "Examples\SharedClients\SharedClients.csproj", "{988A87EF-EAEA-4313-A6CF-FA869813D5AB}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CryptoExchange.Net.Protobuf", "CryptoExchange.Net.Protobuf\CryptoExchange.Net.Protobuf.csproj", "{CC6A807A-9183-6F41-8EF1-8A70172B0E83}"
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -43,10 +41,6 @@ Global
 		{988A87EF-EAEA-4313-A6CF-FA869813D5AB}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{988A87EF-EAEA-4313-A6CF-FA869813D5AB}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{988A87EF-EAEA-4313-A6CF-FA869813D5AB}.Release|Any CPU.Build.0 = Release|Any CPU
-		{CC6A807A-9183-6F41-8EF1-8A70172B0E83}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{CC6A807A-9183-6F41-8EF1-8A70172B0E83}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{CC6A807A-9183-6F41-8EF1-8A70172B0E83}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{CC6A807A-9183-6F41-8EF1-8A70172B0E83}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

CryptoExchange.Net/Authentication/ApiCredentials.cs

@@ -1,101 +1,19 @@
-using System;
-using System.IO;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.Authentication
+namespace CryptoExchange.Net.Authentication
 {
     /// <summary>
     /// Api credentials, used to sign requests accessing private endpoints
     /// </summary>
-    public class ApiCredentials
+    public abstract class ApiCredentials
     {
         /// <summary>
-        /// The api key / label to authenticate requests
+        /// Validate the API credentials
         /// </summary>
-        public string Key { get; set; }
-
-        /// <summary>
-        /// The api secret or private key to authenticate requests
-        /// </summary>
-        public string Secret { get; set; }
-
-        /// <summary>
-        /// The api passphrase. Not needed on all exchanges
-        /// </summary>
-        public string? Pass { get; set; }
-
-        /// <summary>
-        /// Type of the credentials
-        /// </summary>
-        public ApiCredentialsType CredentialType { get; set; }
-
-        /// <summary>
-        /// Create Api credentials providing an api key and secret for authentication
-        /// </summary>
-        /// <param name="key">The api key / label used for identification</param>
-        /// <param name="secret">The api secret or private key used for signing</param>
-        /// <param name="pass">The api pass for the key. Not always needed</param>
-        /// <param name="credentialType">The type of credentials</param>
-        public ApiCredentials(string key, string secret, string? pass = null, ApiCredentialsType credentialType = ApiCredentialsType.Hmac)
-        {
-            if (string.IsNullOrEmpty(key) || string.IsNullOrEmpty(secret))
-                throw new ArgumentException("Key and secret can't be null/empty");
-
-            CredentialType = credentialType;
-            Key = key;
-            Secret = secret;
-            Pass = pass;
-        }
-
-        /// <summary>
-        /// Create API credentials using an API key and secret generated by the server
-        /// </summary>
-        public static ApiCredentials HmacCredentials(string apiKey, string apiSecret, string? pass)
-        {
-            return new ApiCredentials(apiKey, apiSecret, pass, ApiCredentialsType.Hmac);
-        }
-
-        /// <summary>
-        /// Create API credentials using an API key and an RSA private key in PEM format
-        /// </summary>
-        public static ApiCredentials RsaPemCredentials(string apiKey, string privateKey)
-        {
-            return new ApiCredentials(apiKey, privateKey, credentialType: ApiCredentialsType.RsaPem);
-        }
-
-        /// <summary>
-        /// Create API credentials using an API key and an RSA private key in XML format
-        /// </summary>
-        public static ApiCredentials RsaXmlCredentials(string apiKey, string privateKey)
-        {
-            return new ApiCredentials(apiKey, privateKey, credentialType: ApiCredentialsType.RsaXml);
-        }
-
-        /// <summary>
-        /// Create API credentials using an API key and an Ed25519 private key
-        /// </summary>
-        public static ApiCredentials Ed25519Credentials(string apiKey, string privateKey)
-        {
-            return new ApiCredentials(apiKey, privateKey, credentialType: ApiCredentialsType.Ed25519);
-        }
-
-        /// <summary>
-        /// Load a key from a file
-        /// </summary>
-        public static string ReadFromFile(string path)
-        {
-            using var fileStream = File.OpenRead(path);
-            using var streamReader = new StreamReader(fileStream);
-            return streamReader.ReadToEnd();
-        }
+        public abstract void Validate();
 
         /// <summary>
         /// Copy the credentials
         /// </summary>
         /// <returns></returns>
-        public virtual ApiCredentials Copy()
-        {
-            return new ApiCredentials(Key, Secret, Pass, CredentialType);
-        }
+        public abstract ApiCredentials Copy();
     }
 }

CryptoExchange.Net/Authentication/ApiCredentialsType.cs

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

CryptoExchange.Net/Authentication/AuthenticationProvider.cs

@@ -13,6 +13,7 @@ using System.Security.Cryptography;
 using System.Text;
 using CryptoExchange.Net.Sockets;
 using CryptoExchange.Net.Sockets.Default;
+using System.Net;
 
 namespace CryptoExchange.Net.Authentication
 {
@@ -24,58 +25,9 @@ namespace CryptoExchange.Net.Authentication
         internal IAuthTimeProvider TimeProvider { get; set; } = new AuthTimeProvider();
 
         /// <summary>
-        /// The supported credential types
+        /// The public identifier for the provided credentials
         /// </summary>
-        public abstract ApiCredentialsType[] SupportedCredentialTypes { get; }
-
-        /// <summary>
-        /// Provided credentials
-        /// </summary>
-        protected internal readonly ApiCredentials _credentials;
-
-        /// <summary>
-        /// Byte representation of the secret
-        /// </summary>
-        protected byte[] _sBytes;
-
-#if NET8_0_OR_GREATER
-        /// <summary>
-        /// The Ed25519 private key
-        /// </summary>
-        protected Key? Ed25519Key;
-#endif
-
-        /// <summary>
-        /// Get the API key of the current credentials
-        /// </summary>
-        public string ApiKey => _credentials.Key!;
-        /// <summary>
-        /// Get the Passphrase of the current credentials
-        /// </summary>
-        public string? Pass => _credentials.Pass;
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="credentials"></param>
-        protected AuthenticationProvider(ApiCredentials credentials)
-        {
-            if (credentials.Key == null || credentials.Secret == null)
-                throw new ArgumentException("ApiKey/Secret needed");
-
-            if (!SupportedCredentialTypes.Any(x => x == credentials.CredentialType))
-                throw new ArgumentException($"Credential type {credentials.CredentialType} not supported");
-
-            if (credentials.CredentialType == ApiCredentialsType.Ed25519)
-            {
-#if !NET8_0_OR_GREATER
-                throw new ArgumentException($"Credential type Ed25519 only supported on Net8.0 or newer");
-#endif
-            }
-
-            _credentials = credentials;
-            _sBytes = Encoding.UTF8.GetBytes(credentials.Secret);
-        }
+        public abstract string Key { get; }
 
         /// <summary>
         /// Authenticate a REST request
@@ -276,21 +228,15 @@ namespace CryptoExchange.Net.Authentication
         /// <summary>
         /// HMACSHA256 sign the data and return the hash
         /// </summary>
-        /// <param name="data">Data to sign</param>
-        /// <param name="outputType">String type</param>
-        /// <returns></returns>
-        protected string SignHMACSHA256(string data, SignOutputType? outputType = null)
-            => SignHMACSHA256(Encoding.UTF8.GetBytes(data), outputType);
+        protected string SignHMACSHA256(HMACCredential credential, string data, SignOutputType? outputType = null)
+            => SignHMACSHA256(credential,Encoding.UTF8.GetBytes(data), outputType);
 
         /// <summary>
         /// HMACSHA256 sign the data and return the hash
         /// </summary>
-        /// <param name="data">Data to sign</param>
-        /// <param name="outputType">String type</param>
-        /// <returns></returns>
-        protected string SignHMACSHA256(byte[] data, SignOutputType? outputType = null)
+        protected string SignHMACSHA256(HMACCredential credential, byte[] data, SignOutputType? outputType = null)
         {
-            using var encryptor = new HMACSHA256(_sBytes);
+            using var encryptor = new HMACSHA256(credential.GetSBytes());
             var resultBytes = encryptor.ComputeHash(data);
             return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
         }
@@ -298,21 +244,15 @@ namespace CryptoExchange.Net.Authentication
         /// <summary>
         /// HMACSHA384 sign the data and return the hash
         /// </summary>
-        /// <param name="data">Data to sign</param>
-        /// <param name="outputType">String type</param>
-        /// <returns></returns>
-        protected string SignHMACSHA384(string data, SignOutputType? outputType = null)
-            => SignHMACSHA384(Encoding.UTF8.GetBytes(data), outputType);
+        protected string SignHMACSHA384(HMACCredential credential, string data, SignOutputType? outputType = null)
+            => SignHMACSHA384(credential, Encoding.UTF8.GetBytes(data), outputType);
 
         /// <summary>
         /// HMACSHA384 sign the data and return the hash
         /// </summary>
-        /// <param name="data">Data to sign</param>
-        /// <param name="outputType">String type</param>
-        /// <returns></returns>
-        protected string SignHMACSHA384(byte[] data, SignOutputType? outputType = null)
+        protected string SignHMACSHA384(HMACCredential credential, byte[] data, SignOutputType? outputType = null)
         {
-            using var encryptor = new HMACSHA384(_sBytes);
+            using var encryptor = new HMACSHA384(credential.GetSBytes());
             var resultBytes = encryptor.ComputeHash(data);
             return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
         }
@@ -320,21 +260,15 @@ namespace CryptoExchange.Net.Authentication
         /// <summary>
         /// HMACSHA512 sign the data and return the hash
         /// </summary>
-        /// <param name="data">Data to sign</param>
-        /// <param name="outputType">String type</param>
-        /// <returns></returns>
-        protected string SignHMACSHA512(string data, SignOutputType? outputType = null)
-            => SignHMACSHA512(Encoding.UTF8.GetBytes(data), outputType);
+        protected string SignHMACSHA512(HMACCredential credential, string data, SignOutputType? outputType = null)
+            => SignHMACSHA512(credential, Encoding.UTF8.GetBytes(data), outputType);
 
         /// <summary>
         /// HMACSHA512 sign the data and return the hash
         /// </summary>
-        /// <param name="data">Data to sign</param>
-        /// <param name="outputType">String type</param>
-        /// <returns></returns>
-        protected string SignHMACSHA512(byte[] data, SignOutputType? outputType = null)
+        protected string SignHMACSHA512(HMACCredential credential, byte[] data, SignOutputType? outputType = null)
         {
-            using var encryptor = new HMACSHA512(_sBytes);
+            using var encryptor = new HMACSHA512(credential.GetSBytes());
             var resultBytes = encryptor.ComputeHash(data);
             return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
         }
@@ -342,27 +276,21 @@ namespace CryptoExchange.Net.Authentication
         /// <summary>
         /// SHA256 sign the data
         /// </summary>
-        /// <param name="data"></param>
-        /// <param name="outputType"></param>
-        /// <returns></returns>
-        protected string SignRSASHA256(byte[] data, SignOutputType? outputType = null)
+        protected string SignRSASHA256(RSACredential credential, byte[] data, SignOutputType? outputType = null)
         {
-            using var rsa = CreateRSA();
+            var rsa = credential.GetSigner();
             using var sha256 = SHA256.Create();
             var hash = sha256.ComputeHash(data);
             var resultBytes = rsa.SignHash(hash, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
-            return outputType == SignOutputType.Base64? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
         }
 
         /// <summary>
         /// SHA384 sign the data
         /// </summary>
-        /// <param name="data"></param>
-        /// <param name="outputType"></param>
-        /// <returns></returns>
-        protected string SignRSASHA384(byte[] data, SignOutputType? outputType = null)
+        protected string SignRSASHA384(RSACredential credential, byte[] data, SignOutputType? outputType = null)
         {
-            using var rsa = CreateRSA();
+            var rsa = credential.GetSigner();
             using var sha384 = SHA384.Create();
             var hash = sha384.ComputeHash(data);
             var resultBytes = rsa.SignHash(hash, HashAlgorithmName.SHA384, RSASignaturePadding.Pkcs1);
@@ -372,79 +300,32 @@ namespace CryptoExchange.Net.Authentication
         /// <summary>
         /// SHA512 sign the data
         /// </summary>
-        /// <param name="data"></param>
-        /// <param name="outputType"></param>
-        /// <returns></returns>
-        protected string SignRSASHA512(byte[] data, SignOutputType? outputType = null)
+        protected string SignRSASHA512(RSACredential credential, byte[] data, SignOutputType? outputType = null)
         {
-            using var rsa = CreateRSA();
+            var rsa = credential.GetSigner();
             using var sha512 = SHA512.Create();
             var hash = sha512.ComputeHash(data);
             var resultBytes = rsa.SignHash(hash, HashAlgorithmName.SHA512, RSASignaturePadding.Pkcs1);
             return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
         }
 
-        /// <summary>
-        /// Ed25519 sign the data 
-        /// </summary>
-        public string SignEd25519(string data, SignOutputType? outputType = null)
-            => SignEd25519(Encoding.ASCII.GetBytes(data), outputType);
-
-        /// <summary>
-        /// Ed25519 sign the data 
-        /// </summary>
-        public string SignEd25519(byte[] data, SignOutputType? outputType = null)
-        {
 #if NET8_0_OR_GREATER
-            if (Ed25519Key == null)
-            {
-                var key = _credentials.Secret!
-                        .Replace("\n", "")
-                        .Replace("-----BEGIN PRIVATE KEY-----", "")
-                        .Replace("-----END PRIVATE KEY-----", "")
-                        .Trim();
-                var keyBytes = Convert.FromBase64String(key);
-                Ed25519Key = Key.Import(SignatureAlgorithm.Ed25519, keyBytes, KeyBlobFormat.PkixPrivateKey);
-            }
+        /// <summary>
+        /// Ed25519 sign the data 
+        /// </summary>
+        public string SignEd25519(Ed25519Credential credential, string data, SignOutputType? outputType = null)
+            => SignEd25519(credential, Encoding.ASCII.GetBytes(data), outputType);
 
-            var resultBytes = SignatureAlgorithm.Ed25519.Sign(Ed25519Key, data);
-            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
-#else
-            throw new InvalidOperationException();
-#endif
-        }
-
-        private RSA CreateRSA()
+        /// <summary>
+        /// Ed25519 sign the data 
+        /// </summary>
+        public string SignEd25519(Ed25519Credential credential, byte[] data, SignOutputType? outputType = null)
         {
-            var rsa = RSA.Create();
-            if (_credentials.CredentialType == ApiCredentialsType.RsaPem)
-            {
-#if NETSTANDARD2_1_OR_GREATER || NET9_0_OR_GREATER
-                // Read from pem private key
-                var key = _credentials.Secret!
-                        .Replace("\n", "")
-                        .Replace("-----BEGIN PRIVATE KEY-----", "")
-                        .Replace("-----END PRIVATE KEY-----", "")
-                        .Trim();
-                rsa.ImportPkcs8PrivateKey(Convert.FromBase64String(
-                    key)
-                    , out _);
-#else
-                throw new Exception("Pem format not supported when running from .NetStandard2.0. Convert the private key to xml format.");
-#endif
-            }
-            else if (_credentials.CredentialType == ApiCredentialsType.RsaXml)
-            {
-                // Read from xml private key format
-                rsa.FromXmlString(_credentials.Secret!);
-            }
-            else
-            {
-                throw new Exception("Invalid credentials type");
-            }
-
-            return rsa;
+            var signKey = credential.GetSigningKey();
+            var resultBytes = SignatureAlgorithm.Ed25519.Sign(signKey, data);
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
         }
+#endif
 
         /// <summary>
         /// Convert byte array to hex string
@@ -518,11 +399,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>
@@ -568,17 +452,179 @@ namespace CryptoExchange.Net.Authentication
     }
 
     /// <inheritdoc />
-    public abstract class AuthenticationProvider<TApiCredentials> : AuthenticationProvider where TApiCredentials : ApiCredentials
+    public abstract class AuthenticationProvider<TApiCredentials> : AuthenticationProvider
+        where TApiCredentials: ApiCredentials
     {
-        /// <inheritdoc />
-        protected new TApiCredentials _credentials => (TApiCredentials)base._credentials;
+        /// <summary>
+        /// API credentials used for signing requests
+        /// </summary>
+        public TApiCredentials ApiCredentials { get; set; }
 
         /// <summary>
         /// ctor
         /// </summary>
-        /// <param name="credentials"></param>
-        protected AuthenticationProvider(TApiCredentials credentials) : base(credentials)
+        protected AuthenticationProvider(TApiCredentials credentials)
         {
+            credentials.Validate();
+
+            ApiCredentials = credentials;
         }
     }
+
+    /// <inheritdoc />
+    public abstract class AuthenticationProvider<TApiCredentials, TCredentialType> : AuthenticationProvider<TApiCredentials>
+        where TApiCredentials : ApiCredentials
+        where TCredentialType : CredentialSet
+    {
+        /// <summary>
+        /// The specific credential type used for signing requests.
+        /// </summary>
+        public TCredentialType Credential { get; }
+
+        /// <inheritdoc />
+        public override string Key => Credential.Key;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected AuthenticationProvider(
+            TApiCredentials credentials,
+            TCredentialType? credential) : base(credentials)
+        {
+            if (credential == null)
+                throw new ArgumentException($"Missing \"{typeof(TCredentialType).Name}\" credentials on \"{credentials.GetType().Name}\"");
+
+            Credential = credential;
+        }
+        
+        /// <summary>
+        /// HMACSHA256 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected string SignHMACSHA256(string data, SignOutputType? outputType = null)
+            => SignHMACSHA256(Encoding.UTF8.GetBytes(data), outputType);
+
+        /// <summary>
+        /// HMACSHA256 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected string SignHMACSHA256(byte[] data, SignOutputType? outputType = null)
+        {
+            if (Credential is not HMACCredential hmacCredential)
+                throw new InvalidOperationException($"Invalid HMAC signing without HMAC credentials provided");
+
+            return SignHMACSHA256(hmacCredential, data, outputType);
+        }
+
+        /// <summary>
+        /// HMACSHA384 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected string SignHMACSHA384(string data, SignOutputType? outputType = null)
+            => SignHMACSHA384(Encoding.UTF8.GetBytes(data), outputType);
+
+        /// <summary>
+        /// HMACSHA384 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected string SignHMACSHA384(byte[] data, SignOutputType? outputType = null)
+        {
+            if (Credential is not HMACCredential hmacCredential)
+                throw new InvalidOperationException($"Invalid HMAC signing without HMAC credentials provided");
+
+            return SignHMACSHA384(hmacCredential, data, outputType);
+        }
+
+        /// <summary>
+        /// HMACSHA512 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected string SignHMACSHA512(string data, SignOutputType? outputType = null)
+            => SignHMACSHA512(Encoding.UTF8.GetBytes(data), outputType);
+
+        /// <summary>
+        /// HMACSHA512 sign the data and return the hash
+        /// </summary>
+        /// <param name="data">Data to sign</param>
+        /// <param name="outputType">String type</param>
+        /// <returns></returns>
+        protected string SignHMACSHA512(byte[] data, SignOutputType? outputType = null)
+        {
+            if (Credential is not HMACCredential hmacCredential)
+                throw new InvalidOperationException($"Invalid HMAC signing without HMAC credentials provided");
+
+            return SignHMACSHA512(hmacCredential, data, outputType);
+        }
+
+        /// <summary>
+        /// SHA256 sign the data
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="outputType"></param>
+        /// <returns></returns>
+        protected string SignRSASHA256(byte[] data, SignOutputType? outputType = null)
+        {
+            if (Credential is not RSACredential rsaCredential)
+                throw new InvalidOperationException($"Invalid RSA signing without RSA credentials provided");
+
+            return SignRSASHA256(rsaCredential, data, outputType);
+        }
+
+        /// <summary>
+        /// SHA384 sign the data
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="outputType"></param>
+        /// <returns></returns>
+        protected string SignRSASHA384(byte[] data, SignOutputType? outputType = null)
+        {
+            if (Credential is not RSACredential rsaCredential)
+                throw new InvalidOperationException($"Invalid RSA signing without RSA credentials provided");
+
+            return SignRSASHA384(rsaCredential, data, outputType);
+        }
+
+        /// <summary>
+        /// SHA512 sign the data
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="outputType"></param>
+        /// <returns></returns>
+        protected string SignRSASHA512(byte[] data, SignOutputType? outputType = null)
+        {
+            if (Credential is not RSACredential rsaCredential)
+                throw new InvalidOperationException($"Invalid RSA signing without RSA credentials provided");
+
+            return SignRSASHA512(rsaCredential, data, outputType);
+        }
+
+#if NET8_0_OR_GREATER
+        /// <summary>
+        /// Ed25519 sign the data 
+        /// </summary>
+        public string SignEd25519(string data, SignOutputType? outputType = null)
+            => SignEd25519(Encoding.ASCII.GetBytes(data), outputType);
+
+        /// <summary>
+        /// Ed25519 sign the data 
+        /// </summary>
+        public string SignEd25519(byte[] data, SignOutputType? outputType = null)
+        {
+            if (Credential is not Ed25519Credential ed25519Credential)
+                throw new InvalidOperationException($"Invalid Ed25519 signing without Ed25519 credentials provided");
+
+            return SignEd25519(ed25519Credential, data, outputType);
+        }
+#endif
+    }
 }

CryptoExchange.Net/Authentication/CredentialSet.cs

@@ -0,0 +1,569 @@
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
+
+namespace CryptoExchange.Net.Authentication
+{
+    /// <summary>
+    /// Base class for a set of credentials
+    /// </summary>
+    public abstract class CredentialSet : ApiCredentials
+    {
+        /// <summary>
+        /// The (public) key/identifier for this credential pair
+        /// </summary>
+        public string Key { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public CredentialSet() { }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public CredentialSet(string key)
+        {
+            Key = key;
+        }
+
+        /// <summary>
+        /// Validate the API credential
+        /// </summary>
+        public override void Validate()
+        {
+            if (string.IsNullOrEmpty(Key))
+                throw new ArgumentException($"Key not set on {GetType().Name}", nameof(Key));
+        }
+    }
+
+    /// <summary>
+    /// Api key credentials
+    /// </summary>
+    public class ApiKeyCredential : CredentialSet
+    {
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="key">Api key</param>
+        public ApiKeyCredential(string key) : base(key)
+        {
+        }
+
+        /// <inheritdoc />
+        public override ApiCredentials Copy() => new ApiKeyCredential(Key);
+
+    }
+
+    /// <summary>
+    /// HMAC credentials
+    /// </summary>
+    public class HMACCredential : CredentialSet
+    {
+        private byte[]? _sBytes;
+
+        /// <summary>
+        /// API secret
+        /// </summary>
+        public string Secret { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public HMACCredential()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="key">Api key/label</param>
+        /// <param name="secret">Api secret</param>
+        public HMACCredential(string key, string secret) : base(key)
+        {
+            Secret = secret;
+        }
+
+        /// <summary>
+        /// Get the secret value bytes
+        /// </summary>
+        /// <returns></returns>
+        public byte[] GetSBytes()
+        {
+            return _sBytes ??= Encoding.UTF8.GetBytes(Secret);
+        }
+
+        /// <inheritdoc />
+        public override ApiCredentials Copy() => new HMACCredential(Key, Secret);
+
+        /// <inheritdoc />
+        public override void Validate()
+        {
+            base.Validate();
+            if (string.IsNullOrEmpty(Secret))
+                throw new ArgumentException($"Secret not set on {GetType().Name}", nameof(Secret));
+        }
+    }
+
+    /// <summary>
+    /// HMAC credentials
+    /// </summary>
+    public class HMACPassCredential : HMACCredential
+    {
+        /// <summary>
+        /// Passphrase
+        /// </summary>
+        public string Pass { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public HMACPassCredential()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="key">Api key/label</param>
+        /// <param name="secret">Api secret</param>
+        /// <param name="pass">Passphrase</param>
+        public HMACPassCredential(string key, string secret, string pass) : base(key, secret)
+        {
+            Pass = pass;
+        }
+
+
+        /// <inheritdoc />
+        public override ApiCredentials Copy() => new HMACPassCredential(Key, Secret, Pass);
+
+        /// <inheritdoc />
+        public override void Validate()
+        {
+            base.Validate();
+            if (string.IsNullOrEmpty(Pass))
+                throw new ArgumentException($"Pass not set on {GetType().Name}", nameof(Pass));
+        }
+    }
+
+    /// <summary>
+    /// RSA credentials
+    /// </summary>
+    public abstract class RSACredential : CredentialSet
+    {
+        /// <summary>
+        /// Private key
+        /// </summary>
+        public string PrivateKey { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public RSACredential()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="key">Public key</param>
+        /// <param name="privateKey">Private key</param>
+        public RSACredential(string key, string privateKey) : base(key)
+        {
+            PrivateKey = privateKey;
+        }
+
+        /// <summary>
+        /// Get RSA signer
+        /// </summary>
+        public abstract RSA GetSigner();
+
+        /// <inheritdoc />
+        public override void Validate()
+        {
+            base.Validate();
+            if (string.IsNullOrEmpty(PrivateKey))
+                throw new ArgumentException($"PrivateKey not set on {GetType().Name}", nameof(PrivateKey));
+        }
+    }
+
+    /// <summary>
+    /// RSA credentials
+    /// </summary>
+    public abstract class RSAPassCredential : RSACredential
+    {
+        /// <summary>
+        /// Passphrase
+        /// </summary>
+        public string Pass { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public RSAPassCredential()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="key">Public key</param>
+        /// <param name="privateKey">Private key</param>
+        /// <param name="pass">Passphrase</param>
+        public RSAPassCredential(string key, string privateKey, string pass) : base(key, privateKey)
+        {
+            PrivateKey = privateKey;
+            Pass = pass;
+        }
+
+        /// <inheritdoc />
+        public override void Validate()
+        {
+            base.Validate();
+            if (string.IsNullOrEmpty(Pass))
+                throw new ArgumentException($"PrivateKey not set on {GetType().Name}", nameof(PrivateKey));
+        }
+    }
+
+#if NETSTANDARD2_1_OR_GREATER || NET7_0_OR_GREATER
+    /// <summary>
+    /// RSA credentials in PEM/base64 format
+    /// </summary>
+    public class RSAPemCredential : RSACredential
+    {
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public RSAPemCredential()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="key">Public key</param>
+        /// <param name="privateKey">Private key</param>
+        public RSAPemCredential(string key, string privateKey) : base(key, privateKey)
+        {
+        }
+
+        /// <summary>
+        /// Get RSA signer
+        /// </summary>
+        public override RSA GetSigner()
+        {
+            var rsa = RSA.Create();
+            var key = PrivateKey!
+                        .Replace("\n", "")
+                        .Replace("-----BEGIN PRIVATE KEY-----", "")
+                        .Replace("-----END PRIVATE KEY-----", "")
+                        .Trim();
+            rsa.ImportPkcs8PrivateKey(Convert.FromBase64String(
+                key)
+                , out _);
+
+            return rsa;
+        }
+
+        /// <inheritdoc />
+        public override ApiCredentials Copy() => new RSAPemCredential(Key, PrivateKey);        
+    }
+
+    /// <summary>
+    /// RSA PEM/Base64 credentials
+    /// </summary>
+    public class RSAPemPassCredential : RSAPassCredential
+    {
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public RSAPemPassCredential()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="key">Api key/label</param>
+        /// <param name="privateKey">Api secret</param>
+        /// <param name="pass">Passphrase</param>
+        public RSAPemPassCredential(string key, string privateKey, string pass) : base(key, privateKey, pass)
+        {
+        }
+
+        /// <summary>
+        /// Get RSA signer
+        /// </summary>
+        public override RSA GetSigner()
+        {
+            var rsa = RSA.Create();
+            var key = PrivateKey!
+                        .Replace("\n", "")
+                        .Replace("-----BEGIN PRIVATE KEY-----", "")
+                        .Replace("-----END PRIVATE KEY-----", "")
+                        .Trim();
+            rsa.ImportPkcs8PrivateKey(Convert.FromBase64String(
+                key)
+                , out _);
+
+            return rsa;
+        }
+
+        /// <inheritdoc />
+        public override ApiCredentials Copy() => new RSAPemPassCredential(Key, PrivateKey, Pass);
+    }
+#endif
+
+    /// <summary>
+    /// RSA credentials in XML format
+    /// </summary>
+    public class RSAXmlCredential : RSACredential
+    {
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public RSAXmlCredential()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="key">Public key</param>
+        /// <param name="privateKey">Private key</param>
+        public RSAXmlCredential(string key, string privateKey) : base(key, privateKey)
+        {
+        }
+
+        /// <summary>
+        /// Get RSA signer
+        /// </summary>
+        public override RSA GetSigner()
+        {
+            var rsa = RSA.Create();
+            rsa.FromXmlString(PrivateKey);
+            return rsa;
+        }
+
+        /// <inheritdoc />
+        public override ApiCredentials Copy() => new RSAXmlCredential(Key, PrivateKey);
+    }
+
+    /// <summary>
+    /// RSA XML credentials
+    /// </summary>
+    public class RSAXmlPassCredential : RSAPassCredential
+    {
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public RSAXmlPassCredential()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="key">Api key/label</param>
+        /// <param name="privateKey">Api secret</param>
+        /// <param name="pass">Passphrase</param>
+        public RSAXmlPassCredential(string key, string privateKey, string pass) : base(key, privateKey, pass)
+        {
+        }
+
+        /// <summary>
+        /// Get RSA signer
+        /// </summary>
+        public override RSA GetSigner()
+        {
+            var rsa = RSA.Create();
+            rsa.FromXmlString(PrivateKey);
+            return rsa;
+        }
+
+        /// <inheritdoc />
+        public override ApiCredentials Copy() => new RSAXmlPassCredential(Key, PrivateKey, Pass);
+    }
+
+#if NET8_0_OR_GREATER
+    /// <summary>
+    /// Credentials in Ed25519 format
+    /// </summary>
+    public class Ed25519Credential : CredentialSet
+    {
+        private NSec.Cryptography.Key? _signKey;
+
+        /// <summary>
+        /// Private key
+        /// </summary>
+        public string PrivateKey { get; set; }
+        
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public Ed25519Credential()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="key">Public key</param>
+        /// <param name="privateKey">Private key</param>
+        public Ed25519Credential(string key, string privateKey) : base(key)
+        {
+            PrivateKey = privateKey;
+        }
+
+        /// <summary>
+        /// Get signing key
+        /// </summary>
+        public NSec.Cryptography.Key GetSigningKey()
+        {
+            if (_signKey != null)
+                return _signKey;
+
+            var key = PrivateKey!
+                        .Replace("\n", "")
+                        .Replace("-----BEGIN PRIVATE KEY-----", "")
+                        .Replace("-----END PRIVATE KEY-----", "")
+                        .Trim();
+            var keyBytes = Convert.FromBase64String(key);
+            _signKey = NSec.Cryptography.Key.Import(NSec.Cryptography.SignatureAlgorithm.Ed25519, keyBytes, NSec.Cryptography.KeyBlobFormat.PkixPrivateKey);
+            return _signKey;
+        }
+
+        /// <inheritdoc />
+        public override ApiCredentials Copy() => new Ed25519Credential(Key, PrivateKey);
+        
+        /// <inheritdoc />
+        public override void Validate()
+        {
+            base.Validate();
+            if (string.IsNullOrEmpty(PrivateKey))
+                throw new ArgumentException($"PrivateKey not set on {GetType().Name}", nameof(PrivateKey));
+        }
+    }
+
+    /// <summary>
+    /// Ed25519 credentials
+    /// </summary>
+    public class Ed25519PassCredential : Ed25519Credential
+    {
+        /// <summary>
+        /// Passphrase
+        /// </summary>
+        public string Pass { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public Ed25519PassCredential()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="key">Api key/label</param>
+        /// <param name="privateKey">Private key</param>
+        /// <param name="pass">Passphrase</param>
+        public Ed25519PassCredential(string key, string privateKey, string pass) : base(key, privateKey)
+        {
+            Pass = pass;
+        }
+
+        /// <inheritdoc />
+        public override ApiCredentials Copy() => new Ed25519PassCredential(Key, PrivateKey, Pass);
+
+        /// <inheritdoc />
+        public override void Validate()
+        {
+            base.Validate();
+            if (string.IsNullOrEmpty(Pass))
+                throw new ArgumentException($"Pass not set on {GetType().Name}", nameof(Pass));
+        }
+    }
+#endif
+
+    /// <summary>
+    /// Credentials in ECDsa format
+    /// </summary>
+    public class ECDsaCredential : CredentialSet
+    {
+        /// <summary>
+        /// Private key
+        /// </summary>
+        public string PrivateKey { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ECDsaCredential()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="key">Public key</param>
+        /// <param name="privateKey">Private key</param>
+        public ECDsaCredential(string key, string privateKey) : base(key)
+        {
+            PrivateKey = privateKey;
+        }
+
+        /// <inheritdoc />
+        public override ApiCredentials Copy() => new ECDsaCredential(Key, PrivateKey);
+
+        /// <inheritdoc />
+        public override void Validate()
+        {
+            base.Validate();
+            if (string.IsNullOrEmpty(PrivateKey))
+                throw new ArgumentException($"PrivateKey not set on {GetType().Name}", nameof(PrivateKey));
+        }
+    }
+
+    /// <summary>
+    /// ECDsa credentials
+    /// </summary>
+    public class ECDsaPassCredential : ECDsaCredential
+    {
+        /// <summary>
+        /// Passphrase
+        /// </summary>
+        public string Pass { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ECDsaPassCredential()
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="key">Api key/label</param>
+        /// <param name="privateKey">Private key</param>
+        /// <param name="pass">Passphrase</param>
+        public ECDsaPassCredential(string key, string privateKey, string pass) : base(key, privateKey)
+        {
+            Pass = pass;
+        }
+
+        /// <inheritdoc />
+        public override ApiCredentials Copy() => new ECDsaPassCredential(Key, PrivateKey, Pass);
+
+        /// <inheritdoc />
+        public override void Validate()
+        {
+            base.Validate();
+            if (string.IsNullOrEmpty(Pass))
+                throw new ArgumentException($"Pass not set on {GetType().Name}", nameof(Pass));
+        }
+    }
+}

CryptoExchange.Net/Authentication/Signing/CeAbiEncoder.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+
+namespace CryptoExchange.Net.Authentication.Signing
+{
+    /// <summary>
+    /// ABI encoding
+    /// </summary>
+    public static class CeAbiEncoder
+    {
+        /// <summary>
+        /// ABI encode string as Sha3Keccack hashed byte value
+        /// </summary>
+        public static byte[] AbiValueEncodeString(string value)
+        {
+            var abiValueEncoded = CeSha3Keccack.CalculateHash(Encoding.UTF8.GetBytes(value));
+            return abiValueEncoded;
+        }
+
+        /// <summary>
+        /// ABI encode bool value as uint256 with 1 for true and 0 for false, as per ABI specification
+        /// </summary>
+        public static byte[] AbiValueEncodeBool(bool value)
+            => AbiValueEncodeInt((byte)(value ? 1 : 0));
+
+        /// <summary>
+        /// ABI encode byte value as uint256, as per ABI specification
+        /// </summary>
+        public static byte[] AbiValueEncodeInt(byte value)
+            => AbiValueEncodeBigInteger(false, new BigInteger(value));
+
+        /// <summary>
+        /// ABI encode short value as int256, as per ABI specification  
+        /// </summary>
+        public static byte[] AbiValueEncodeInt(short value)
+            => AbiValueEncodeBigInteger(true, new BigInteger(value));
+
+        /// <summary>
+        /// ABI encode int value as int256, as per ABI specification
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static byte[] AbiValueEncodeInt(int value)
+            => AbiValueEncodeBigInteger(true, new BigInteger(value));
+
+        /// <summary>
+        /// ABI encode long value as int256, as per ABI specification
+        /// </summary>
+        public static byte[] AbiValueEncodeInt(long value)
+            => AbiValueEncodeBigInteger(true, new BigInteger(value));
+
+        /// <summary>
+        /// ABI encode ushort value as uint256, as per ABI specification
+        /// </summary>
+        public static byte[] AbiValueEncodeInt(ushort value)
+            => AbiValueEncodeBigInteger(false, new BigInteger(value));
+
+        /// <summary>
+        /// ABI encode uint value as uint256, as per ABI specification
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static byte[] AbiValueEncodeInt(uint value)
+            => AbiValueEncodeBigInteger(false, new BigInteger(value));
+
+        /// <summary>
+        /// ABI encode ulong value as uint256, as per ABI specification
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static byte[] AbiValueEncodeInt(ulong value)
+            => AbiValueEncodeBigInteger(false, new BigInteger(value));
+
+        /// <summary>
+        /// ABI encode big integer value as int256 or uint256, as per ABI specification
+        /// </summary>
+        public static byte[] AbiValueEncodeBigInteger(bool signed, BigInteger value)
+        {
+            var result = new byte[32];
+            if (signed && value < 0)
+            {
+                // Pad with FF
+                for (int i = 0; i < result.Length; i++)
+                {
+                    result[i] = 0xFF;
+                }
+            }
+
+            var t = value.ToByteArray();
+            if (t.Length == 33)
+            {
+                // Strip last byte
+                var strip1 = new byte[32];
+                Array.Copy(t, 0, strip1, 0, 32);
+                t = strip1;
+            }
+
+            if (BitConverter.IsLittleEndian)
+                t = t.AsEnumerable().Reverse().ToArray();
+
+            t.CopyTo(result, result.Length - t.Length);
+            return result;
+        }
+
+        /// <summary>
+        /// ABI encode address value as uint256, as per ABI specification
+        /// </summary>
+        public static byte[] AbiValueEncodeAddress(string value)
+        {
+            var result = new byte[32];
+            var h = value.HexStringToBytes();
+            h.CopyTo(result, result.Length - h.Length);
+            return result;
+        }
+
+        /// <summary>
+        /// ABI encode hex string value as bytes32, as per ABI specification. The hex string is expected to be a 0x prefixed string, and the resulting bytes will be right aligned in the 32 bytes result, with leading zeros if the hex string is shorter than 32 bytes. If the hex string is longer than 32 bytes, an exception will be thrown.
+        /// </summary>
+        /// <param name="length"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static byte[] AbiValueEncodeHexBytes(int length, string value)
+            => AbiValueEncodeBytes(value.Length, value.HexStringToBytes());
+
+        /// <summary>
+        /// ABI encode byte array value as bytes32, as per ABI specification. The resulting bytes will be right aligned in the 32 bytes result, with leading zeros if the byte array is shorter than 32 bytes. If the byte array is longer than 32 bytes, an exception will be thrown.
+        /// </summary>
+        /// <param name="length"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        /// <exception cref="Exception"></exception>
+        public static byte[] AbiValueEncodeBytes(int length, byte[] value)
+        {
+            if (length != 32)
+                throw new Exception("Only 32 bytes size supported");
+
+            if (value.Length == 32)
+                return value;
+
+            var result = new byte[32];
+            value.CopyTo(result, result.Length - value.Length);
+            return result;
+        }
+    }
+}

CryptoExchange.Net/Authentication/Signing/CeEip712TypedDataEncoder.cs

@@ -0,0 +1,304 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace CryptoExchange.Net.Authentication.Signing
+{
+    /// <summary>
+    /// EIP712 Typed Data Encoder
+    /// </summary>
+    public static class CeEip712TypedDataEncoder
+    {
+        /// <summary>
+        /// Encode EIP712 typed data according to the specification, with the provided primary type, domain fields and message fields.
+        /// The resulting byte array is the 0x19 0x01 prefix followed by the hash of the domain and the hash of the message, which can be signed with ECDsa secp256k1 to produce a signature that can be verified on chain with EIP712.
+        /// Note that this implementation does not support all possible EIP712 types, but it should cover most common use cases
+        /// </summary>
+        public static byte[] EncodeEip721(
+            string primaryType,
+            IEnumerable<(string Name, string Type, object Value)> domainFields,
+            IEnumerable<(string Name, string Type, object Value)> messageFields)
+        {
+            var data = new CeTypedDataRaw()
+            {
+                PrimaryType = primaryType,
+                DomainRawValues = domainFields.Select(x => new CeMemberValue
+                {
+                    TypeName = x.Type,
+                    Value = x.Value,
+                }).ToArray(),
+
+                Message = messageFields.Select(x => new CeMemberValue
+                {
+                    TypeName = x.Type,
+                    Value = x.Value,
+                }).ToArray(),
+                Types = new Dictionary<string, CeMemberDescription[]>
+                {
+                    {
+                        "EIP712Domain",
+                        domainFields.Select(x => new CeMemberDescription
+                        {
+                            Name = x.Name,
+                            Type = x.Type
+                        }).ToArray()
+                    },
+                    {
+                        primaryType,
+                        messageFields.Select(x => new CeMemberDescription
+                        {
+                            Name = x.Name,
+                            Type = x.Type
+                        }).ToArray()
+                    }
+                }
+            };
+
+            return EncodeTypedDataRaw(data);
+        }
+
+        /// <summary>
+        /// Encode EIP712 typed data according to the specification, with the provided primary type, domain fields and message fields.
+        /// The resulting byte array is the 0x19 0x01 prefix followed by the hash of the domain and the hash of the message, which can be signed with ECDsa secp256k1 to produce a signature that can be verified on chain with EIP712.
+        /// Note that this implementation does not support all possible EIP712 types, but it should cover most common use cases
+        /// </summary>
+        public static byte[] EncodeTypedDataRaw(CeTypedDataRaw typedData)
+        {
+            using var memoryStream = new MemoryStream();
+            using var writer = new BinaryWriter(memoryStream);
+            
+            // Write 0x19 0x01 prefix
+            writer.Write((byte)0x19);
+            writer.Write((byte)0x01);
+
+            // Write domain
+            writer.Write(HashStruct(typedData.Types, "EIP712Domain", typedData.DomainRawValues));
+
+            // Write message
+            writer.Write(HashStruct(typedData.Types, typedData.PrimaryType, typedData.Message));
+
+            writer.Flush();
+            var result = memoryStream.ToArray();
+            return result;
+            
+        }
+
+        private static byte[] HashStruct(IDictionary<string, CeMemberDescription[]> types, string primaryType, IEnumerable<CeMemberValue> message)
+        {
+            var memoryStream = new MemoryStream();
+            var writer = new BinaryWriter(memoryStream);
+            
+            // Encode the type header
+            EncodeType(writer, types, primaryType);
+
+            // Encode the data
+            EncodeData(writer, types, message);
+
+            writer.Flush();
+            return CeSha3Keccack.CalculateHash(memoryStream.ToArray());
+            
+        }
+
+        private static void EncodeData(BinaryWriter writer, IDictionary<string, CeMemberDescription[]> types, IEnumerable<CeMemberValue> memberValues)
+        {
+            foreach (var memberValue in memberValues)
+            {
+                switch (memberValue.TypeName)
+                {
+                    case var refType when IsReferenceType(refType):
+                        writer.Write(HashStruct(types, memberValue.TypeName, (IEnumerable<CeMemberValue>)memberValue.Value));
+                        break;
+
+                    case "string":
+                        writer.Write(CeAbiEncoder.AbiValueEncodeString((string)memberValue.Value));
+                        break;
+
+                    case "bool":
+                        writer.Write(CeAbiEncoder.AbiValueEncodeBool((bool)memberValue.Value));
+                        break;
+
+                    case "address":
+                        writer.Write(CeAbiEncoder.AbiValueEncodeAddress((string)memberValue.Value));
+                        break;
+
+                    default:
+                        if (memberValue.TypeName.Contains("["))
+                        {
+                            var items = (IList)memberValue.Value;
+                            var itemsMemberValues = new List<CeMemberValue>();
+                            foreach (var item in items)
+                            {
+                                itemsMemberValues.Add(new CeMemberValue()
+                                {
+                                    TypeName = memberValue.TypeName.Substring(0, memberValue.TypeName.LastIndexOf("[")),
+                                    Value = item
+                                });
+                            }
+
+                            var memoryStream = new MemoryStream();
+                            var writerItem = new BinaryWriter(memoryStream);
+
+                            EncodeData(writerItem, types, itemsMemberValues);
+                            writerItem.Flush();
+                            writer.Write(CeSha3Keccack.CalculateHash(memoryStream.ToArray()));
+                        }
+                        else if (memberValue.TypeName.StartsWith("int") || memberValue.TypeName.StartsWith("uint"))
+                        {
+                            if (memberValue.Value is string v)
+                            {
+                                if (!BigInteger.TryParse(v, out BigInteger parsedOutput))
+                                    throw new Exception($"Failed to encode BigInteger string {v}");
+
+                                writer.Write(CeAbiEncoder.AbiValueEncodeBigInteger(memberValue.TypeName[0] != 'u', parsedOutput));
+                            }
+                            else if (memberValue.Value is byte b)
+                            {
+                                writer.Write(CeAbiEncoder.AbiValueEncodeInt(b));
+                            }
+                            else if (memberValue.Value is short s)
+                            {
+                                writer.Write(CeAbiEncoder.AbiValueEncodeInt(s));
+                            }
+                            else if (memberValue.Value is int i)
+                            {
+                                writer.Write(CeAbiEncoder.AbiValueEncodeInt(i));
+                            }
+                            else if (memberValue.Value is long l)
+                            {
+                                writer.Write(CeAbiEncoder.AbiValueEncodeInt(l));
+                            }
+                            else if (memberValue.Value is ushort us)
+                            {
+                                writer.Write(CeAbiEncoder.AbiValueEncodeInt(us));
+                            }
+                            else if (memberValue.Value is uint ui)
+                            {
+                                writer.Write(CeAbiEncoder.AbiValueEncodeInt(ui));
+                            }
+                            else if (memberValue.Value is ulong ul)
+                            {
+                                writer.Write(CeAbiEncoder.AbiValueEncodeInt(ul));
+                            }
+                            else
+                            {
+                                throw new Exception("Unknown number value");
+                            }
+                        }
+                        else if (memberValue.TypeName.StartsWith("bytes"))
+                        {
+                            var length = memberValue.TypeName.Length == 5 ? 32 : int.Parse(memberValue.TypeName.Substring(5));
+                            writer.Write(CeAbiEncoder.AbiValueEncodeBytes(length, (byte[])memberValue.Value));
+                        }
+                        break;
+
+                }
+            }
+        }
+
+        private static void EncodeType(BinaryWriter writer, IDictionary<string, CeMemberDescription[]> types, string typeName)
+        {
+            var encodedTypes = EncodeTypes(types, typeName);
+            var encodedPrimaryType = encodedTypes.Single(x => x.Key == typeName);
+            var encodedReferenceTypes = encodedTypes.Where(x => x.Key != typeName).OrderBy(x => x.Key).Select(x => x.Value);
+            var fullyEncodedType = encodedPrimaryType.Value + string.Join(string.Empty, encodedReferenceTypes.ToArray());
+
+            writer.Write(CeSha3Keccack.CalculateHash(Encoding.UTF8.GetBytes(fullyEncodedType)));
+        }
+
+        /// <summary>
+        /// Create a list of type => type(parameters), for example:<br />
+        /// { IP712Domain, EIP712Domain(string name,string version,uint256 chainId,address verifyingContract) }
+        /// </summary>
+        private static IList<KeyValuePair<string, string>> EncodeTypes(IDictionary<string, CeMemberDescription[]> types, string currentTypeName)
+        {
+            var currentTypeMembers = types[currentTypeName];
+            var currentTypeMembersEncoded = currentTypeMembers.Select(x => x.Type + " " + x.Name);
+            var result = new List<KeyValuePair<string, string>>
+            {
+                new KeyValuePair<string, string>(currentTypeName, currentTypeName + "(" + string.Join(",", currentTypeMembersEncoded.ToArray()) + ")")
+            };
+
+            result.AddRange(currentTypeMembers.Select(x => x.Type.Contains("[") ? x.Type.Substring(0, x.Type.IndexOf("[")) : x.Type)
+                                              .Distinct()
+                                              .Where(IsReferenceType)
+                                              .SelectMany(x => EncodeTypes(types, x)));
+            return result;
+        }
+
+        internal static bool IsReferenceType(string typeName)
+        {
+            switch (typeName)
+            {
+                case var bytes when new Regex("bytes\\d+").IsMatch(bytes):
+                case var @uint when new Regex("uint\\d+").IsMatch(@uint):
+                case var @int when new Regex("int\\d+").IsMatch(@int):
+                case "bytes":
+                case "string":
+                case "bool":
+                case "address":
+                case var array when array.Contains("["):
+                    return false;
+                default:
+                    return true;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Member description
+    /// </summary>
+    public class CeMemberDescription
+    {
+        /// <summary>
+        /// Name
+        /// </summary>
+        public string Name { get; set; } = string.Empty;
+        /// <summary>
+        /// Type
+        /// </summary>
+        public string Type { get; set; } = string.Empty;
+    }
+
+    /// <summary>
+    /// Member value
+    /// </summary>
+    public class CeMemberValue
+    {
+        /// <summary>
+        /// Type name
+        /// </summary>
+        public string TypeName { get; set; } = string.Empty;
+        /// <summary>
+        /// Value
+        /// </summary>
+        public object Value { get; set; } = string.Empty;
+    }
+
+    /// <summary>
+    /// Typed data raw, used for encoding EIP712 typed data with the provided primary type, domain fields and message fields.
+    /// </summary>
+    public class CeTypedDataRaw
+    {
+        /// <summary>
+        /// Type dictionary
+        /// </summary>
+        public IDictionary<string, CeMemberDescription[]> Types { get; set; } = new Dictionary<string, CeMemberDescription[]>();
+        /// <summary>
+        /// Primary type
+        /// </summary>
+        public string PrimaryType { get; set; } = string.Empty;
+        /// <summary>
+        /// Message values
+        /// </summary>
+        public CeMemberValue[] Message { get; set; } = [];
+        /// <summary>
+        /// Domain values
+        /// </summary>
+        public CeMemberValue[] DomainRawValues { get; set; } = [];
+    }
+}

CryptoExchange.Net/Authentication/Signing/CeSha3Keccack.cs

@@ -0,0 +1,385 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+
+namespace CryptoExchange.Net.Authentication.Signing
+{
+    /// <summary>
+    /// Sha3 Keccack hashing, as per Ethereum specification, with 256 bit output
+    /// </summary>
+    public class CeSha3Keccack
+    {
+        /// <summary>
+        /// Calculate the Keccack256 hash of the provided data, as per Ethereum specification
+        /// </summary>
+        public static byte[] CalculateHash(byte[] data)
+        {
+            var digest = new CeKeccakDigest256();
+            var output = new byte[digest.GetDigestSize()];
+            digest.BlockUpdate(data, data.Length);
+            digest.DoFinal(output, 0);
+            return output;
+        }
+    }
+
+    internal class CeKeccakDigest256
+    {
+        private static readonly ulong[] _keccakRoundConstants = KeccakInitializeRoundConstants();
+        private static readonly int[] _keccakRhoOffsets = KeccakInitializeRhoOffsets();
+
+        private readonly int _rate;
+        private const int _stateLength = 1600 / 8;
+        private readonly ulong[] _state = new ulong[_stateLength / 8];
+        private readonly byte[] _dataQueue = new byte[1536 / 8];
+        private int _bitsInQueue;
+        private int _fixedOutputLength;
+        private bool _squeezing;
+        private int _bitsAvailableForSqueezing;
+
+        public CeKeccakDigest256()
+        {
+            _rate = 1600 - (256 << 1);
+            _bitsInQueue = 0;
+            _squeezing = false;
+            _bitsAvailableForSqueezing = 0;
+            _fixedOutputLength = 1600 - _rate >> 1;
+        }
+
+        internal void BlockUpdate(byte[] data, int length)
+        {
+            int bytesInQueue = _bitsInQueue >> 3;
+            int rateBytes = _rate >> 3;
+
+            int count = 0;
+            while (count < length)
+            {
+                if (bytesInQueue == 0 && count <= length - rateBytes)
+                {
+                    do
+                    {
+                        KeccakAbsorb(data, count);
+                        count += rateBytes;
+                    } while (count <= length - rateBytes);
+                }
+                else
+                {
+                    int partialBlock = Math.Min(rateBytes - bytesInQueue, length - count);
+                    Array.Copy(data, count, _dataQueue, bytesInQueue, partialBlock);
+
+                    bytesInQueue += partialBlock;
+                    count += partialBlock;
+
+                    if (bytesInQueue == rateBytes)
+                    {
+                        KeccakAbsorb(_dataQueue, 0);
+                        bytesInQueue = 0;
+                    }
+                }
+            }
+
+            _bitsInQueue = bytesInQueue << 3;
+        }
+
+        internal void DoFinal(byte[] output, int outOff)
+        {
+            Squeeze(output, outOff, _fixedOutputLength >> 3);
+        }
+
+        internal int GetDigestSize() => _fixedOutputLength >> 3;
+
+        protected void Squeeze(byte[] output, int off, int len)
+        {
+            if (!_squeezing)
+                PadAndSwitchToSqueezingPhase();
+
+            long outputLength = (long)len << 3;
+            long i = 0;
+            while (i < outputLength)
+            {
+                if (_bitsAvailableForSqueezing == 0)
+                {
+                    KeccakPermutation();
+                    KeccakExtract();
+                    _bitsAvailableForSqueezing = _rate;
+                }
+
+                int partialBlock = (int)Math.Min(_bitsAvailableForSqueezing, outputLength - i);
+                Array.Copy(_dataQueue, _rate - _bitsAvailableForSqueezing >> 3, output, off + (int)(i >> 3),
+                    partialBlock >> 3);
+                _bitsAvailableForSqueezing -= partialBlock;
+                i += partialBlock;
+            }
+        }
+
+        private static ulong[] KeccakInitializeRoundConstants()
+        {
+            ulong[] keccakRoundConstants = new ulong[24];
+            byte LFSRState = 0x01;
+
+            for (int i = 0; i < 24; i++)
+            {
+                keccakRoundConstants[i] = 0;
+                for (int j = 0; j < 7; j++)
+                {
+                    int bitPosition = (1 << j) - 1;
+
+                    // LFSR86540
+
+                    bool loBit = (LFSRState & 0x01) != 0;
+                    if (loBit)
+                        keccakRoundConstants[i] ^= 1UL << bitPosition;
+
+                    bool hiBit = (LFSRState & 0x80) != 0;
+                    LFSRState <<= 1;
+                    if (hiBit)
+                        LFSRState ^= 0x71;
+                }
+            }
+
+            return keccakRoundConstants;
+        }
+        private static int[] KeccakInitializeRhoOffsets()
+        {
+            int[] keccakRhoOffsets = new int[25];
+            int x, y, t, newX, newY;
+
+            int rhoOffset = 0;
+            keccakRhoOffsets[0] = rhoOffset;
+            x = 1;
+            y = 0;
+            for (t = 1; t < 25; t++)
+            {
+                rhoOffset = rhoOffset + t & 63;
+                keccakRhoOffsets[x % 5 + 5 * (y % 5)] = rhoOffset;
+                newX = (0 * x + 1 * y) % 5;
+                newY = (2 * x + 3 * y) % 5;
+                x = newX;
+                y = newY;
+            }
+
+            return keccakRhoOffsets;
+        }
+
+        private void KeccakAbsorb(byte[] data, int off)
+        {
+            int count = _rate >> 6;
+            for (int i = 0; i < count; ++i)
+            {
+                _state[i] ^= Pack.LeToUInt64(data, off);
+                off += 8;
+            }
+
+            KeccakPermutation();
+        }
+
+        private void KeccakPermutation()
+        {
+            for (int i = 0; i < 24; i++)
+            {
+                Theta(_state);
+                Rho(_state);
+                Pi(_state);
+                Chi(_state);
+                Iota(_state, i);
+            }
+        }
+        private static ulong LeftRotate(ulong v, int r)
+        {
+            return v << r | v >> -r;
+        }
+
+        private static void Theta(ulong[] A)
+        {
+            ulong C0 = A[0 + 0] ^ A[0 + 5] ^ A[0 + 10] ^ A[0 + 15] ^ A[0 + 20];
+            ulong C1 = A[1 + 0] ^ A[1 + 5] ^ A[1 + 10] ^ A[1 + 15] ^ A[1 + 20];
+            ulong C2 = A[2 + 0] ^ A[2 + 5] ^ A[2 + 10] ^ A[2 + 15] ^ A[2 + 20];
+            ulong C3 = A[3 + 0] ^ A[3 + 5] ^ A[3 + 10] ^ A[3 + 15] ^ A[3 + 20];
+            ulong C4 = A[4 + 0] ^ A[4 + 5] ^ A[4 + 10] ^ A[4 + 15] ^ A[4 + 20];
+
+            ulong dX = LeftRotate(C1, 1) ^ C4;
+
+            A[0] ^= dX;
+            A[5] ^= dX;
+            A[10] ^= dX;
+            A[15] ^= dX;
+            A[20] ^= dX;
+
+            dX = LeftRotate(C2, 1) ^ C0;
+
+            A[1] ^= dX;
+            A[6] ^= dX;
+            A[11] ^= dX;
+            A[16] ^= dX;
+            A[21] ^= dX;
+
+            dX = LeftRotate(C3, 1) ^ C1;
+
+            A[2] ^= dX;
+            A[7] ^= dX;
+            A[12] ^= dX;
+            A[17] ^= dX;
+            A[22] ^= dX;
+
+            dX = LeftRotate(C4, 1) ^ C2;
+
+            A[3] ^= dX;
+            A[8] ^= dX;
+            A[13] ^= dX;
+            A[18] ^= dX;
+            A[23] ^= dX;
+
+            dX = LeftRotate(C0, 1) ^ C3;
+
+            A[4] ^= dX;
+            A[9] ^= dX;
+            A[14] ^= dX;
+            A[19] ^= dX;
+            A[24] ^= dX;
+        }
+
+        private static void Rho(ulong[] A)
+        {
+            // KeccakRhoOffsets[0] == 0
+            for (int x = 1; x < 25; x++)
+            {
+                A[x] = LeftRotate(A[x], _keccakRhoOffsets[x]);
+            }
+        }
+
+        private static void Pi(ulong[] A)
+        {
+            ulong a1 = A[1];
+            A[1] = A[6];
+            A[6] = A[9];
+            A[9] = A[22];
+            A[22] = A[14];
+            A[14] = A[20];
+            A[20] = A[2];
+            A[2] = A[12];
+            A[12] = A[13];
+            A[13] = A[19];
+            A[19] = A[23];
+            A[23] = A[15];
+            A[15] = A[4];
+            A[4] = A[24];
+            A[24] = A[21];
+            A[21] = A[8];
+            A[8] = A[16];
+            A[16] = A[5];
+            A[5] = A[3];
+            A[3] = A[18];
+            A[18] = A[17];
+            A[17] = A[11];
+            A[11] = A[7];
+            A[7] = A[10];
+            A[10] = a1;
+        }
+
+        private static void Chi(ulong[] A)
+        {
+            ulong chiC0, chiC1, chiC2, chiC3, chiC4;
+
+            for (int yBy5 = 0; yBy5 < 25; yBy5 += 5)
+            {
+                chiC0 = A[0 + yBy5] ^ ~A[(0 + 1) % 5 + yBy5] & A[(0 + 2) % 5 + yBy5];
+                chiC1 = A[1 + yBy5] ^ ~A[(1 + 1) % 5 + yBy5] & A[(1 + 2) % 5 + yBy5];
+                chiC2 = A[2 + yBy5] ^ ~A[(2 + 1) % 5 + yBy5] & A[(2 + 2) % 5 + yBy5];
+                chiC3 = A[3 + yBy5] ^ ~A[(3 + 1) % 5 + yBy5] & A[(3 + 2) % 5 + yBy5];
+                chiC4 = A[4 + yBy5] ^ ~A[(4 + 1) % 5 + yBy5] & A[(4 + 2) % 5 + yBy5];
+
+                A[0 + yBy5] = chiC0;
+                A[1 + yBy5] = chiC1;
+                A[2 + yBy5] = chiC2;
+                A[3 + yBy5] = chiC3;
+                A[4 + yBy5] = chiC4;
+            }
+        }
+
+        private static void Iota(ulong[] A, int indexRound)
+        {
+            A[0] ^= _keccakRoundConstants[indexRound];
+        }
+
+        private void PadAndSwitchToSqueezingPhase()
+        {
+            Debug.Assert(_bitsInQueue < _rate);
+
+            _dataQueue[_bitsInQueue >> 3] |= (byte)(1U << (_bitsInQueue & 7));
+
+            if (++_bitsInQueue == _rate)
+            {
+                KeccakAbsorb(_dataQueue, 0);
+                _bitsInQueue = 0;
+            }
+
+            {
+                int full = _bitsInQueue >> 6, partial = _bitsInQueue & 63;
+                int off = 0;
+                for (int i = 0; i < full; ++i)
+                {
+                    _state[i] ^= Pack.LeToUInt64(_dataQueue, off);
+                    off += 8;
+                }
+
+                if (partial > 0)
+                {
+                    ulong mask = (1UL << partial) - 1UL;
+                    _state[full] ^= Pack.LeToUInt64(_dataQueue, off) & mask;
+                }
+
+                _state[_rate - 1 >> 6] ^= 1UL << 63;
+            }
+
+            KeccakPermutation();
+            KeccakExtract();
+            _bitsAvailableForSqueezing = _rate;
+
+            _bitsInQueue = 0;
+            _squeezing = true;
+        }
+        private void KeccakExtract()
+        {
+            Pack.UInt64ToLe(_state, 0, _rate >> 6, _dataQueue, 0);
+        }
+
+        static class Pack
+        {
+            internal static ulong LeToUInt64(byte[] bs, int off)
+            {
+                uint lo = LeToUInt32(bs, off);
+                uint hi = LeToUInt32(bs, off + 4);
+                return (ulong)hi << 32 | lo;
+            }
+            internal static uint LeToUInt32(byte[] bs, int off)
+            {
+                return bs[off]
+                       | (uint)bs[off + 1] << 8
+                       | (uint)bs[off + 2] << 16
+                       | (uint)bs[off + 3] << 24;
+            }
+
+            internal static void UInt64ToLe(ulong[] ns, int nsOff, int nsLen, byte[] bs, int bsOff)
+            {
+                for (int i = 0; i < nsLen; ++i)
+                {
+                    UInt64ToLe(ns[nsOff + i], bs, bsOff);
+                    bsOff += 8;
+                }
+            }
+            internal static void UInt64ToLe(ulong n, byte[] bs, int off)
+            {
+                UInt32ToLe((uint)n, bs, off);
+                UInt32ToLe((uint)(n >> 32), bs, off + 4);
+            }
+
+            internal static void UInt32ToLe(uint n, byte[] bs, int off)
+            {
+                bs[off] = (byte)n;
+                bs[off + 1] = (byte)(n >> 8);
+                bs[off + 2] = (byte)(n >> 16);
+                bs[off + 3] = (byte)(n >> 24);
+            }
+        }
+    }
+}

CryptoExchange.Net/Clients/BaseApiClient.cs

@@ -1,5 +1,4 @@
 using System;
-using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Interfaces.Clients;
 using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Options;
@@ -13,7 +12,10 @@ namespace CryptoExchange.Net.Clients
     /// </summary>
     public abstract class BaseApiClient : IDisposable, IBaseApiClient
     {
-        private string? _clientName;
+        /// <summary>
+        /// Client name
+        /// </summary>
+        protected string? _clientName;
 
         /// <summary>
         /// Logger
@@ -25,6 +27,11 @@ namespace CryptoExchange.Net.Clients
         /// </summary>
         protected bool _disposing;
 
+        /// <summary>
+        /// Whether a proxy is configured
+        /// </summary>
+        protected bool _proxyConfigured;
+
         /// <summary>
         /// Name of the client
         /// </summary>
@@ -40,11 +47,6 @@ namespace CryptoExchange.Net.Clients
             }
         }
 
-        /// <summary>
-        /// The authentication provider for this API client. (null if no credentials are set)
-        /// </summary>
-        public AuthenticationProvider? AuthenticationProvider { get; private set; }
-
         /// <summary>
         /// The environment this client communicates to
         /// </summary>
@@ -55,12 +57,6 @@ namespace CryptoExchange.Net.Clients
         /// </summary>
         public bool OutputOriginalData { get; }
 
-        /// <inheritdoc />
-        public bool Authenticated => ApiCredentials != null;
-
-        /// <inheritdoc />
-        public ApiCredentials? ApiCredentials { get; set; }
-
         /// <summary>
         /// Api options
         /// </summary>
@@ -82,10 +78,14 @@ namespace CryptoExchange.Net.Clients
         /// <param name="logger">Logger</param>
         /// <param name="outputOriginalData">Should data from this client include the original data in the call result</param>
         /// <param name="baseAddress">Base address for this API client</param>
-        /// <param name="apiCredentials">Api credentials</param>
         /// <param name="clientOptions">Client options</param>
         /// <param name="apiOptions">Api options</param>
-        protected BaseApiClient(ILogger logger, bool outputOriginalData, ApiCredentials? apiCredentials, string baseAddress, ExchangeOptions clientOptions, ApiOptions apiOptions)
+        protected BaseApiClient(
+            ILogger logger,
+            bool outputOriginalData,
+            string baseAddress,
+            ExchangeOptions clientOptions,
+            ApiOptions apiOptions)
         {
             _logger = logger;
 
@@ -93,19 +93,10 @@ namespace CryptoExchange.Net.Clients
             ApiOptions = apiOptions;
             OutputOriginalData = outputOriginalData;
             BaseAddress = baseAddress;
-            ApiCredentials = apiCredentials?.Copy();
 
-            if (ApiCredentials != null)
-                AuthenticationProvider = CreateAuthenticationProvider(ApiCredentials);
+            _proxyConfigured = ClientOptions.Proxy != null;
         }
 
-        /// <summary>
-        /// Create an AuthenticationProvider implementation instance based on the provided credentials
-        /// </summary>
-        /// <param name="credentials"></param>
-        /// <returns></returns>
-        protected abstract AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials);
-
         /// <inheritdoc />
         public abstract string FormatSymbol(string baseAsset, string quoteAsset, TradingMode tradingMode, DateTime? deliverDate = null);
 
@@ -119,25 +110,6 @@ namespace CryptoExchange.Net.Clients
         /// </summary>
         public ErrorInfo GetErrorInfo(string code, string? message = null) => ErrorMapping.GetErrorInfo(code.ToString(), message);
 
-        /// <inheritdoc />
-        public void SetApiCredentials<T>(T credentials) where T : ApiCredentials
-        {
-            ApiCredentials = credentials?.Copy();
-            if (ApiCredentials != null)
-                AuthenticationProvider = CreateAuthenticationProvider(ApiCredentials);
-        }
-
-        /// <inheritdoc />
-        public virtual void SetOptions<T>(UpdateOptions<T> options) where T : ApiCredentials
-        {
-            ClientOptions.Proxy = options.Proxy;
-            ClientOptions.RequestTimeout = options.RequestTimeout ?? ClientOptions.RequestTimeout;
-
-            ApiCredentials = options.ApiCredentials?.Copy() ?? ApiCredentials;
-            if (ApiCredentials != null)
-                AuthenticationProvider = CreateAuthenticationProvider(ApiCredentials);
-        }
-
         /// <summary>
         /// Dispose
         /// </summary>

CryptoExchange.Net/Clients/BaseClient.cs

@@ -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>
@@ -87,16 +92,6 @@ namespace CryptoExchange.Net.Clients
             _logger.Log(LogLevel.Trace, $"Client configuration: {options}, CryptoExchange.Net: v{CryptoExchangeLibVersion}, {Exchange}.Net: v{ExchangeLibVersion}");
         }
 
-        /// <summary>
-        /// Set the API credentials for this client. All Api clients in this client will use the new credentials, regardless of earlier set options.
-        /// </summary>
-        /// <param name="credentials">The credentials to set</param>
-        protected virtual void SetApiCredentials<T>(T credentials) where T : ApiCredentials
-        {
-            foreach (var apiClient in ApiClients)
-                apiClient.SetApiCredentials(credentials);
-        }
-
         /// <summary>
         /// Register an API client
         /// </summary>
@@ -125,6 +120,8 @@ namespace CryptoExchange.Net.Clients
         /// </summary>
         public virtual void Dispose()
         {
+            Disposed = true;
+
             foreach (var client in ApiClients)
                 client.Dispose();
         }

CryptoExchange.Net/Clients/BaseRestClient.cs

@@ -1,7 +1,11 @@
-using System.Linq;
+using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Interfaces.Clients;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Options;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace CryptoExchange.Net.Clients
 {
@@ -10,6 +14,11 @@ namespace CryptoExchange.Net.Clients
     /// </summary>
     public abstract class BaseRestClient : BaseClient, IRestClient
     {
+        /// <summary>
+        /// Api clients in this client
+        /// </summary>
+        internal new List<RestApiClient> ApiClients => base.ApiClients.OfType<RestApiClient>().ToList();
+
         /// <inheritdoc />
         public int TotalRequestsMade => ApiClients.OfType<RestApiClient>().Sum(s => s.TotalRequestsMade);
 
@@ -24,5 +33,59 @@ namespace CryptoExchange.Net.Clients
 
             LibraryHelpers.StaticLogger = loggerFactory?.CreateLogger("CryptoExchange");
         }
+
+        /// <summary>
+        /// Update options
+        /// </summary>
+        public virtual void SetOptions(UpdateOptions options)
+        {
+            foreach (var apiClient in ApiClients)
+                apiClient.SetOptions(options);
+        }
     }
-}
+
+    /// <inheritdoc />
+    public abstract class BaseRestClient<TEnvironment, TApiCredentials> : BaseRestClient, IRestClient<TApiCredentials>
+        where TEnvironment : TradeEnvironment
+        where TApiCredentials : ApiCredentials
+    {
+        /// <summary>
+        /// Api clients in this client
+        /// </summary>
+        internal new List<RestApiClient<TEnvironment, TApiCredentials>> ApiClients => base.ApiClients.OfType<RestApiClient<TEnvironment, TApiCredentials>>().ToList();
+
+        /// <summary>
+        /// Provided client options
+        /// </summary>
+        public new RestExchangeOptions<TEnvironment, TApiCredentials> ClientOptions => (RestExchangeOptions<TEnvironment, TApiCredentials>)base.ClientOptions;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="loggerFactory">Logger factory</param>
+        /// <param name="name">The name of the API this client is for</param>
+        protected BaseRestClient(ILoggerFactory? loggerFactory, string name) : base(loggerFactory, name)
+        {
+        }
+
+        /// <summary>
+        /// Set the API credentials for this client. All Api clients in this client will use the new credentials, regardless of earlier set options.
+        /// </summary>
+        /// <param name="credentials">The credentials to set</param>
+        public void SetApiCredentials(TApiCredentials credentials)
+        {
+            foreach (var apiClient in ApiClients)
+                apiClient.SetApiCredentials(credentials);
+        }
+
+        /// <summary>
+        /// Update options
+        /// </summary>
+        public virtual void SetOptions(UpdateOptions<TApiCredentials> options)
+        {
+            foreach (var apiClient in ApiClients)
+                apiClient.SetOptions(options);
+        }
+
+    }
+}

CryptoExchange.Net/Clients/BaseSocketClient.cs

@@ -1,5 +1,7 @@
-using CryptoExchange.Net.Interfaces.Clients;
+using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Interfaces.Clients;
 using CryptoExchange.Net.Logging.Extensions;
+using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.Objects.Sockets;
 using Microsoft.Extensions.Logging;
@@ -19,6 +21,11 @@ namespace CryptoExchange.Net.Clients
     {
         #region fields
 
+        /// <summary>
+        /// Api clients in this client
+        /// </summary>
+        internal new List<SocketApiClient> ApiClients => base.ApiClients.OfType<SocketApiClient>().ToList();
+
         /// <summary>
         /// If client is disposing
         /// </summary>
@@ -133,5 +140,58 @@ namespace CryptoExchange.Net.Clients
 
             return result;
         }
+
+        /// <summary>
+        /// Update options
+        /// </summary>
+        public virtual void SetOptions(UpdateOptions options)
+        {
+            foreach (var apiClient in ApiClients)
+                apiClient.SetOptions(options);
+        }
+    }
+
+    /// <inheritdoc />
+    public abstract class BaseSocketClient<TEnvironment, TApiCredentials> : BaseSocketClient, ISocketClient<TApiCredentials>
+        where TEnvironment : TradeEnvironment
+        where TApiCredentials : ApiCredentials
+    {
+        /// <summary>
+        /// Api clients in this client
+        /// </summary>
+        internal new List<SocketApiClient<TEnvironment, TApiCredentials>> ApiClients => base.ApiClients.OfType<SocketApiClient<TEnvironment, TApiCredentials>>().ToList();
+
+        /// <summary>
+        /// Provided client options
+        /// </summary>
+        public new SocketExchangeOptions<TEnvironment, TApiCredentials> ClientOptions => (SocketExchangeOptions<TEnvironment, TApiCredentials>)base.ClientOptions;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="loggerFactory">Logger factory</param>
+        /// <param name="name">The name of the API this client is for</param>
+        protected BaseSocketClient(ILoggerFactory? loggerFactory, string name) : base(loggerFactory, name)
+        {
+        }
+
+        /// <summary>
+        /// Set the API credentials for this client. All Api clients in this client will use the new credentials, regardless of earlier set options.
+        /// </summary>
+        /// <param name="credentials">The credentials to set</param>
+        public virtual void SetApiCredentials(TApiCredentials credentials)
+        {
+            foreach (var apiClient in ApiClients)
+                apiClient.SetApiCredentials(credentials);
+        }
+
+        /// <summary>
+        /// Update options
+        /// </summary>
+        public virtual void SetOptions(UpdateOptions<TApiCredentials> options)
+        {
+            foreach (var apiClient in ApiClients)
+                apiClient.SetOptions(options);
+        }
     }
 }

CryptoExchange.Net/Clients/CryptoBaseClient.cs

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

CryptoExchange.Net/Clients/CryptoRestClient.cs

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

CryptoExchange.Net/Clients/CryptoSocketClient.cs

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

CryptoExchange.Net/Clients/RestApiClient.cs

@@ -1,3 +1,4 @@
+using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Caching;
 using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
 using CryptoExchange.Net.Interfaces;
@@ -77,6 +78,16 @@ namespace CryptoExchange.Net.Clients
             { new HttpMethod("Patch"), HttpMethodParameterPosition.InBody },
         };
 
+        /// <summary>
+        /// Encoding/charset for the ContentType header
+        /// </summary>
+        protected Encoding? RequestBodyContentEncoding { get; set; } = Encoding.UTF8;
+
+        /// <summary>
+        /// Whether to omit the ContentType header if there is no content
+        /// </summary>
+        protected bool OmitContentTypeHeaderWithoutContent { get; set; } = false;
+
         /// <inheritdoc />
         public new RestExchangeOptions ClientOptions => (RestExchangeOptions)base.ClientOptions;
 
@@ -92,7 +103,17 @@ namespace CryptoExchange.Net.Clients
         /// The message handler
         /// </summary>
         protected abstract IRestMessageHandler MessageHandler { get; }
+
+        /// <summary>
+        /// Get the AuthenticationProvider implementation, or null if no ApiCredentials are set
+        /// </summary>
+        public virtual AuthenticationProvider? GetAuthenticationProvider() => null;
         
+        /// <summary>
+        /// Configured environment name
+        /// </summary>
+        public abstract string EnvironmentName { get; }
+
         /// <summary>
         /// ctor
         /// </summary>
@@ -101,10 +122,13 @@ namespace CryptoExchange.Net.Clients
         /// <param name="baseAddress">Base address for this API client</param>
         /// <param name="options">The base client options</param>
         /// <param name="apiOptions">The Api client options</param>
-        public RestApiClient(ILogger logger, HttpClient? httpClient, string baseAddress, RestExchangeOptions options, RestApiOptions apiOptions)
+        public RestApiClient(ILogger logger,
+            HttpClient? httpClient,
+            string baseAddress,
+            RestExchangeOptions options,
+            RestApiOptions apiOptions)
             : base(logger,
                   apiOptions.OutputOriginalData ?? options.OutputOriginalData,
-                  apiOptions.ApiCredentials ?? options.ApiCredentials,
                   baseAddress,
                   options,
                   apiOptions)
@@ -114,12 +138,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>
@@ -210,7 +228,7 @@ namespace CryptoExchange.Net.Clients
             string? rateLimitKeySuffix = null)
         {
             var requestId = ExchangeHelpers.NextId();
-            if (definition.Authenticated && AuthenticationProvider == null)
+            if (definition.Authenticated && GetAuthenticationProvider() == null)
             {
                 _logger.RestApiNoApiCredentials(requestId, definition.Path);
                 return new WebCallResult<T>(new NoApiCredentialsError());
@@ -315,7 +333,17 @@ namespace CryptoExchange.Net.Clients
 
                 if (ClientOptions.RateLimiterEnabled)
                 {
-                    var limitResult = await definition.RateLimitGate.ProcessAsync(_logger, requestId, RateLimitItemType.Request, definition, host, AuthenticationProvider?._credentials.Key, requestWeight, ClientOptions.RateLimitingBehaviour, rateLimitKeySuffix, cancellationToken).ConfigureAwait(false);
+                    var limitResult = await definition.RateLimitGate.ProcessAsync(
+                        _logger,
+                        requestId,
+                        RateLimitItemType.Request,
+                        definition,
+                        host,
+                        GetAuthenticationProvider()?.Key,
+                        requestWeight, 
+                        ClientOptions.RateLimitingBehaviour,
+                        rateLimitKeySuffix + ClientOptions.RateLimitGroup,
+                        cancellationToken).ConfigureAwait(false);
                     if (!limitResult)
                         return limitResult.Error!;
                 }
@@ -330,7 +358,18 @@ namespace CryptoExchange.Net.Clients
                 if (ClientOptions.RateLimiterEnabled)
                 {
                     var singleRequestWeight = weightSingleLimiter ?? 1;
-                    var limitResult = await definition.RateLimitGate.ProcessSingleAsync(_logger, requestId, definition.LimitGuard, RateLimitItemType.Request, definition, host, AuthenticationProvider?._credentials.Key, singleRequestWeight, ClientOptions.RateLimitingBehaviour, rateLimitKeySuffix, cancellationToken).ConfigureAwait(false);
+                    var limitResult = await definition.RateLimitGate.ProcessSingleAsync(
+                        _logger,
+                        requestId, 
+                        definition.LimitGuard,
+                        RateLimitItemType.Request,
+                        definition,
+                        host, 
+                        GetAuthenticationProvider()?.Key,
+                        singleRequestWeight,
+                        ClientOptions.RateLimitingBehaviour,
+                        rateLimitKeySuffix,
+                        cancellationToken).ConfigureAwait(false);
                     if (!limitResult)
                         return limitResult.Error!;
                 }
@@ -369,7 +408,7 @@ namespace CryptoExchange.Net.Clients
 
             try
             {
-                AuthenticationProvider?.ProcessRequest(this, requestConfiguration);
+                GetAuthenticationProvider()?.ProcessRequest(this, requestConfiguration);
             }
             catch (Exception ex)
             {
@@ -380,7 +419,11 @@ namespace CryptoExchange.Net.Clients
             if (!string.IsNullOrEmpty(queryString) && !queryString.StartsWith("?"))
                 queryString = $"?{queryString}";
 
-            var uri = new Uri(baseAddress.AppendPath(definition.Path) + queryString);
+            var path = baseAddress.AppendPath(definition.Path);
+            if (definition.ForcePathEndWithSlash == true && !path.EndsWith("/"))
+                path += "/";
+
+            var uri = new Uri(path + queryString);
             var request = RequestFactory.Create(ClientOptions.HttpVersion, definition.Method, uri, requestId);
             request.Accept = MessageHandler.AcceptHeader;
 
@@ -404,14 +447,14 @@ namespace CryptoExchange.Net.Clients
                 var bodyContent = requestConfiguration.GetBodyContent();
                 if (bodyContent != null)
                 {
-                    request.SetContent(bodyContent, contentType);
+                    request.SetContent(bodyContent, RequestBodyContentEncoding, contentType);
                 }
                 else
                 {
                     if (requestConfiguration.BodyParameters != null && requestConfiguration.BodyParameters.Count != 0)
                         WriteParamBody(request, requestConfiguration.BodyParameters, contentType);
-                    else
-                        request.SetContent(RequestBodyEmptyContent, contentType);
+                    else if (OmitContentTypeHeaderWithoutContent != true)
+                        request.SetContent(RequestBodyEmptyContent, RequestBodyContentEncoding, contentType);                    
                 }
             }
 
@@ -443,26 +486,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);
-
-                        if (_logger.IsEnabled(LogLevel.Trace))
-                            _logger.RestApiReceivedResponse(request.RequestId, originalData);
+                        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)
@@ -488,13 +524,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)
                         {
@@ -660,13 +695,13 @@ namespace CryptoExchange.Net.Clients
                     stringData = stringSerializer.Serialize(value);
                 else
                     stringData = stringSerializer.Serialize(parameters);
-                request.SetContent(stringData, contentType);
+                request.SetContent(stringData, RequestBodyContentEncoding, contentType);
             }
             else if (contentType == Constants.FormContentHeader)
             {
                 // Write the parameters as form data in the body
                 var stringData = parameters.ToFormData();
-                request.SetContent(stringData, contentType);
+                request.SetContent(stringData, RequestBodyContentEncoding, contentType);
             }
         }
 
@@ -689,14 +724,6 @@ namespace CryptoExchange.Net.Clients
         /// <returns>Server time</returns>
         protected virtual Task<WebCallResult<DateTime>> GetServerTimestampAsync() => throw new NotImplementedException();
 
-        /// <inheritdoc />
-        public override void SetOptions<T>(UpdateOptions<T> options)
-        {
-            base.SetOptions(options);
-
-            RequestFactory.UpdateSettings(options.Proxy, options.RequestTimeout ?? ClientOptions.RequestTimeout, ClientOptions.HttpKeepAliveInterval);
-        }
-
         private async ValueTask CheckTimeSync(int requestId, RequestDefinition definition)
         {
             if (!definition.Authenticated)
@@ -730,7 +757,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");
@@ -769,10 +805,184 @@ 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
             && !definition.PreventCaching;
 
+
+        /// <inheritdoc />
+        public virtual void SetOptions(UpdateOptions options)
+        {
+            _proxyConfigured = options.Proxy != null;
+            ClientOptions.Proxy = options.Proxy;
+            ClientOptions.RequestTimeout = options.RequestTimeout ?? ClientOptions.RequestTimeout;
+
+            RequestFactory.UpdateSettings(options.Proxy, options.RequestTimeout ?? ClientOptions.RequestTimeout, ClientOptions.HttpKeepAliveInterval);
+        }
+    }
+
+    /// <inheritdoc />
+    public abstract class RestApiClient<TEnvironment> : RestApiClient, IRestApiClient
+        where TEnvironment : TradeEnvironment
+    {
+        /// <inheritdoc />
+        public new RestExchangeOptions<TEnvironment> ClientOptions => (RestExchangeOptions<TEnvironment>)base.ClientOptions;
+
+        /// <inheritdoc />
+        public override string EnvironmentName => ClientOptions.Environment.Name;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected RestApiClient(
+            ILogger logger,
+            HttpClient? httpClient,
+            string baseAddress,
+            RestExchangeOptions options,
+            RestApiOptions apiOptions) : base(
+                logger,
+                httpClient,
+                baseAddress,
+                options,
+                apiOptions)
+        {
+        }
+    }
+
+    /// <inheritdoc />
+    public abstract class RestApiClient<TEnvironment, TApiCredentials> : RestApiClient<TEnvironment>, IRestApiClient<TApiCredentials>
+        where TApiCredentials : ApiCredentials
+        where TEnvironment : TradeEnvironment
+    {
+        /// <inheritdoc />
+        public TApiCredentials? ApiCredentials { get; set; }
+
+        /// <inheritdoc />
+        public bool Authenticated => ApiCredentials != null;
+
+        /// <inheritdoc />
+        public new RestExchangeOptions<TEnvironment, TApiCredentials> ClientOptions => (RestExchangeOptions<TEnvironment, TApiCredentials>)base.ClientOptions;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected RestApiClient(
+            ILogger logger,
+            HttpClient? httpClient,
+            string baseAddress,
+            RestExchangeOptions<TEnvironment, TApiCredentials> options,
+            RestApiOptions apiOptions) : base(
+                logger,
+                httpClient,
+                baseAddress,
+                options,
+                apiOptions)
+        {
+            ApiCredentials =  options.ApiCredentials;
+        }
+
+        /// <inheritdoc />
+        public virtual void SetApiCredentials(TApiCredentials credentials)
+        {
+            ApiCredentials = (TApiCredentials)credentials.Copy();
+        }
+
+        /// <inheritdoc />
+        public virtual void SetOptions(UpdateOptions<TApiCredentials> options)
+        {
+            base.SetOptions(options);
+
+            ApiCredentials = (TApiCredentials?)options.ApiCredentials?.Copy() ?? ApiCredentials;
+        }
+    }
+
+    /// <inheritdoc />
+    public abstract class RestApiClient<TEnvironment, TAuthenticationProvider, TApiCredentials> : RestApiClient<TEnvironment, TApiCredentials>
+        where TApiCredentials : ApiCredentials
+        where TAuthenticationProvider : AuthenticationProvider<TApiCredentials>
+        where TEnvironment : TradeEnvironment
+    {
+
+        private bool _authProviderInitialized = false;
+        private TAuthenticationProvider? _authenticationProvider;
+        /// <summary>
+        /// The authentication provider for this API client. (null if no credentials are set)
+        /// </summary>
+        public TAuthenticationProvider? AuthenticationProvider
+        {
+            get
+            {
+                if (!_authProviderInitialized)
+                {
+                    if (ApiCredentials != null)
+                        _authenticationProvider = CreateAuthenticationProvider(ApiCredentials);
+
+                    _authProviderInitialized = true;
+                }
+
+                return _authenticationProvider;
+            }
+            internal set => _authenticationProvider = value;
+        }
+
+        /// <inheritdoc />
+        public override AuthenticationProvider? GetAuthenticationProvider() => AuthenticationProvider;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected RestApiClient(
+            ILogger logger, 
+            HttpClient? httpClient,
+            string baseAddress,
+            RestExchangeOptions<TEnvironment, TApiCredentials> options, 
+            RestApiOptions apiOptions) : base(
+                logger, 
+                httpClient,
+                baseAddress,
+                options, 
+                apiOptions)
+        {
+        }
+
+        /// <summary>
+        /// Create an AuthenticationProvider implementation instance based on the provided credentials
+        /// </summary>
+        /// <param name="credentials"></param>
+        /// <returns></returns>
+        protected abstract TAuthenticationProvider CreateAuthenticationProvider(TApiCredentials credentials);
+
+        /// <inheritdoc />
+        public override void SetApiCredentials(TApiCredentials credentials)
+        {
+            base.SetApiCredentials(credentials);
+
+            AuthenticationProvider = null;
+            _authProviderInitialized = false;
+            ApiCredentials = credentials;
+        }
+
+        /// <inheritdoc />
+        public override void SetOptions(UpdateOptions<TApiCredentials> options)
+        {
+            base.SetOptions(options);
+
+            if (options.ApiCredentials != null)
+            {
+                AuthenticationProvider = null;
+                _authProviderInitialized = false;
+                ApiCredentials = options.ApiCredentials;
+            }
+        }
     }
 }

CryptoExchange.Net/Clients/SocketApiClient.cs

@@ -1,3 +1,4 @@
+using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Interfaces.Clients;
@@ -19,6 +20,7 @@ using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net.Http;
 using System.Net.WebSockets;
 using System.Text;
 using System.Threading;
@@ -99,11 +101,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
         {
@@ -146,6 +143,16 @@ namespace CryptoExchange.Net.Clients
         /// Whether or not to enforce that sequence number updates are always (lastSequenceNumber + 1)
         /// </summary>
         public bool EnforceSequenceNumbers { get; set; }
+
+        /// <summary>
+        /// Get the AuthenticationProvider implementation, or null if no ApiCredentials are set
+        /// </summary>
+        public virtual AuthenticationProvider? GetAuthenticationProvider() => null;
+
+        /// <summary>
+        /// Configured environment name
+        /// </summary>
+        public abstract string EnvironmentName { get; }
         #endregion
 
         /// <summary>
@@ -155,22 +162,19 @@ namespace CryptoExchange.Net.Clients
         /// <param name="options">Client options</param>
         /// <param name="baseAddress">Base address for this API client</param>
         /// <param name="apiOptions">The Api client options</param>
-        public SocketApiClient(ILogger logger, string baseAddress, SocketExchangeOptions options, SocketApiOptions apiOptions)
+        public SocketApiClient(
+            ILogger logger, 
+            string baseAddress, 
+            SocketExchangeOptions options,
+            SocketApiOptions apiOptions)
             : base(logger,
                   apiOptions.OutputOriginalData ?? options.OutputOriginalData,
-                  apiOptions.ApiCredentials ?? options.ApiCredentials,
                   baseAddress,
                   options,
                   apiOptions)
         {
         }
 
-        /// <summary>
-        /// Create a message accessor instance
-        /// </summary>
-        /// <returns></returns>
-        protected internal abstract IByteMessageAccessor CreateAccessor(WebSocketMessageType messageType);
-
         /// <summary>
         /// Create a serializer instance
         /// </summary>
@@ -246,7 +250,7 @@ namespace CryptoExchange.Net.Clients
             if (_disposing)
                 return new CallResult<UpdateSubscription>(new InvalidOperationError("Client disposed, can't subscribe"));
 
-            if (subscription.Authenticated && AuthenticationProvider == null)
+            if (subscription.Authenticated && GetAuthenticationProvider() == null)
             {
                 _logger.LogWarning("Failed to subscribe, private subscription but no API credentials set");
                 return new CallResult<UpdateSubscription>(new NoApiCredentialsError());
@@ -315,52 +319,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));
@@ -422,8 +383,6 @@ namespace CryptoExchange.Net.Clients
                         released = true;
                     }
 
-                    var needsConnecting = !socketConnection.Connected;
-
                     var connectResult = await ConnectIfNeededAsync(socketConnection, false, ct).ConfigureAwait(false);
                     if (!connectResult)
                         return new CallResult<HighPerfUpdateSubscription>(connectResult.Error!);
@@ -569,7 +528,7 @@ namespace CryptoExchange.Net.Clients
         /// <returns></returns>
         public virtual async Task<CallResult> AuthenticateSocketAsync(SocketConnection socket)
         {
-            if (AuthenticationProvider == null)
+            if (GetAuthenticationProvider() == null)
                 return new CallResult(new NoApiCredentialsError());
 
             _logger.AttemptingToAuthenticate(socket.SocketId);
@@ -600,7 +559,7 @@ namespace CryptoExchange.Net.Clients
         /// </summary>
         /// <returns></returns>
         protected internal virtual Task<Query?> GetAuthenticationRequestAsync(SocketConnection connection) => 
-            Task.FromResult(AuthenticationProvider!.GetAuthenticationQuery(this, connection));
+            Task.FromResult(GetAuthenticationProvider()!.GetAuthenticationQuery(this, connection));
 
         /// <summary>
         /// Adds a system subscription. Used for example to reply to ping requests
@@ -751,7 +710,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 +760,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 +820,6 @@ namespace CryptoExchange.Net.Clients
                 Proxy = ClientOptions.Proxy,
                 Timeout = ApiOptions.SocketNoDataTimeout ?? ClientOptions.SocketNoDataTimeout,
                 ReceiveBufferSize = ClientOptions.ReceiveBufferSize,
-                UseUpdatedDeserialization = ClientOptions.UseUpdatedDeserialization
             };
 
         /// <summary>
@@ -969,25 +925,6 @@ namespace CryptoExchange.Net.Clients
             return CallResult.SuccessResult;
         }
 
-        /// <inheritdoc />
-        public override void SetOptions<T>(UpdateOptions<T> options)
-        {
-            var previousProxyIsSet = ClientOptions.Proxy != null;
-            base.SetOptions(options);
-
-            if ((!previousProxyIsSet && options.Proxy == null)
-                || _socketConnections.IsEmpty)
-            {
-                return;
-            }
-
-            _logger.LogInformation("Reconnecting websockets to apply proxy");
-
-            // Update proxy, also triggers reconnect
-            foreach (var connection in _socketConnections)
-                _ = connection.Value.UpdateProxy(options.Proxy);
-        }
-
         /// <summary>
         /// Log the current state of connections and subscriptions
         /// </summary>
@@ -1056,7 +993,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,26 +1023,184 @@ 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
         /// </summary>
         /// <returns></returns>
         public abstract ISocketMessageHandler CreateMessageConverter(WebSocketMessageType messageType);
+
+        /// <inheritdoc />
+        public virtual void SetOptions(UpdateOptions options)
+        {
+            var previousProxyIsSet = _proxyConfigured;
+
+            ClientOptions.Proxy = options.Proxy;
+            ClientOptions.RequestTimeout = options.RequestTimeout ?? ClientOptions.RequestTimeout;
+
+            _proxyConfigured = options.Proxy != null;
+            if ((!previousProxyIsSet && options.Proxy == null)
+                || _socketConnections.IsEmpty)
+            {
+                return;
+            }
+
+            _logger.LogInformation("Reconnecting websockets to apply proxy");
+
+            // Update proxy, also triggers reconnect
+            foreach (var connection in _socketConnections)
+                _ = connection.Value.UpdateProxy(options.Proxy);
+        }
+    }
+
+    /// <inheritdoc />
+    public abstract class SocketApiClient<TEnvironment> : SocketApiClient, ISocketApiClient
+       where TEnvironment : TradeEnvironment
+    {
+        /// <inheritdoc />
+        public new SocketExchangeOptions<TEnvironment> ClientOptions => (SocketExchangeOptions<TEnvironment>)base.ClientOptions;
+
+        /// <inheritdoc />
+        public override string EnvironmentName => ClientOptions.Environment.Name;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected SocketApiClient(
+            ILogger logger,
+            string baseAddress,
+            SocketExchangeOptions<TEnvironment> options,
+            SocketApiOptions apiOptions) : base(
+                logger,
+                baseAddress,
+                options,
+                apiOptions)
+        {
+        }
+    }
+
+    /// <inheritdoc />
+    public abstract class SocketApiClient<TEnvironment, TApiCredentials> : SocketApiClient<TEnvironment>, ISocketApiClient<TApiCredentials>
+        where TApiCredentials : ApiCredentials
+        where TEnvironment : TradeEnvironment
+    {
+        /// <inheritdoc />
+        public TApiCredentials? ApiCredentials { get; set; }
+
+        /// <inheritdoc />
+        public bool Authenticated => ApiCredentials != null;
+
+        /// <inheritdoc />
+        public new SocketExchangeOptions<TEnvironment, TApiCredentials> ClientOptions => (SocketExchangeOptions<TEnvironment, TApiCredentials>)base.ClientOptions;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected SocketApiClient(
+            ILogger logger,
+            string baseAddress,
+            SocketExchangeOptions<TEnvironment, TApiCredentials> options,
+            SocketApiOptions apiOptions) : base(
+                logger,
+                baseAddress,
+                options,
+                apiOptions)
+        {
+            ApiCredentials = options.ApiCredentials;
+        }
+
+        /// <inheritdoc />
+        public virtual void SetApiCredentials(TApiCredentials credentials)
+        {
+            ApiCredentials = (TApiCredentials)credentials.Copy();
+        }
+
+        /// <inheritdoc />
+        public virtual void SetOptions(UpdateOptions<TApiCredentials> options)
+        {
+            base.SetOptions(options);
+        }
+    }
+
+    /// <inheritdoc />
+    public abstract class SocketApiClient<TEnvironment, TAuthenticationProvider, TApiCredentials> : SocketApiClient<TEnvironment, TApiCredentials>
+        where TAuthenticationProvider : AuthenticationProvider<TApiCredentials>
+        where TApiCredentials : ApiCredentials
+        where TEnvironment : TradeEnvironment
+    {
+
+        private bool _authProviderInitialized = false;
+        private TAuthenticationProvider? _authenticationProvider;
+        /// <summary>
+        /// The authentication provider for this API client. (null if no credentials are set)
+        /// </summary>
+        public TAuthenticationProvider? AuthenticationProvider
+        {
+            get
+            {
+                if (!_authProviderInitialized)
+                {
+                    if (ApiCredentials != null)
+                        _authenticationProvider = CreateAuthenticationProvider(ApiCredentials);
+
+                    _authProviderInitialized = true;
+                }
+
+                return _authenticationProvider;
+            }
+            internal set => _authenticationProvider = value;
+        }
+
+        /// <inheritdoc />
+        public override AuthenticationProvider? GetAuthenticationProvider() => AuthenticationProvider;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected SocketApiClient(
+            ILogger logger,
+            string baseAddress,
+            SocketExchangeOptions<TEnvironment, TApiCredentials> options,
+            SocketApiOptions apiOptions) : base(
+                logger,
+                baseAddress,
+                options,
+                apiOptions)
+        {
+        }
+
+        /// <summary>
+        /// Create an AuthenticationProvider implementation instance based on the provided credentials
+        /// </summary>
+        /// <param name="credentials"></param>
+        /// <returns></returns>
+        protected abstract TAuthenticationProvider CreateAuthenticationProvider(TApiCredentials credentials);
+
+        /// <inheritdoc />
+        public override void SetApiCredentials(TApiCredentials credentials)
+        {
+            AuthenticationProvider = null;
+            _authProviderInitialized = false;
+            ApiCredentials = credentials;
+
+            base.SetApiCredentials(credentials);
+        }
+
+        /// <inheritdoc />
+        public override void SetOptions(UpdateOptions<TApiCredentials> options)
+        {
+            if (options.ApiCredentials != null)
+            {
+                AuthenticationProvider = null;
+                _authProviderInitialized = false;
+                ApiCredentials = options.ApiCredentials;
+            }
+
+            base.SetOptions(options);
+        }
     }
 }

CryptoExchange.Net/Converters/MessageParsing/MessageNode.cs

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

CryptoExchange.Net/Converters/MessageParsing/MessagePath.cs

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

CryptoExchange.Net/Converters/MessageParsing/MessagePathExtension.cs

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

CryptoExchange.Net/Converters/MessageParsing/NodeType.cs

@@ -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
-    }
-}

CryptoExchange.Net/Converters/SystemTextJson/CommaSplitStringConverter.cs

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

CryptoExchange.Net/Converters/SystemTextJson/EnumConverter.cs

@@ -67,28 +67,29 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 #endif
          : JsonConverter<T>, INullableConverterFactory where T : struct, Enum
     {
-        class EnumMapping
-        {
-            public T Value { get; set; }
-            public string StringValue { get; set; }
-
-            public EnumMapping(T value, string stringValue)
-            {
-                Value = value;
-                StringValue = stringValue;
-            }
-        }
 
 #if NET8_0_OR_GREATER
-        private static FrozenSet<EnumMapping>? _mappingToEnum = null;
+        private static FrozenDictionary<string, T>? _mappingToEnum = null;
         private static FrozenDictionary<T, string>? _mappingToString = null;
+
+        private static bool RunOptimistic => true;
 #else
-        private static List<EnumMapping>? _mappingToEnum = null;
+        private static Dictionary<string, T>? _mappingToEnum = null;
         private static Dictionary<T, string>? _mappingToString = null;
+        
+        // In NetStandard the `ValueTextEquals` method used is slower than just string comparing
+        // so only bother in newer frameworks
+        private static bool RunOptimistic => false;
 #endif
         private NullableEnumConverter? _nullableEnumConverter = null;
 
+        private static Type _enumType = typeof(T);
+        private static T? _undefinedEnumValue;
+        private static bool _hasFlagsAttribute = _enumType.IsDefined(typeof(FlagsAttribute));
         private static ConcurrentBag<string> _unknownValuesWarned = new ConcurrentBag<string>();
+        private static ConcurrentBag<string> _notOptimalValuesWarned = new ConcurrentBag<string>();
+
+        private const int _optimisticValueCountThreshold = 6;
 
         internal class NullableEnumConverter : JsonConverter<T?>
         {
@@ -119,30 +120,51 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         /// <inheritdoc />
         public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
-            var t = ReadNullable(ref reader, typeToConvert, options, out var isEmptyString);
-            if (t == null)
-            {
-                if (isEmptyString && !_unknownValuesWarned.Contains(null))
-                {
-                    // We received an empty string and have no mapping for it, and the property isn't nullable
-                    LibraryHelpers.StaticLogger?.LogWarning($"Received null or empty enum value, but property type is not a nullable enum. EnumType: {typeof(T).FullName}. If you think {typeof(T).FullName} should be nullable please open an issue on the Github repo");
-                }
-
-                return new T(); // return default value
-            }
-            else
-            {
+            var t = ReadNullable(ref reader, typeToConvert, options, out var isEmptyStringOrNull);
+            if (t != null)
                 return t.Value;
+            
+            if (isEmptyStringOrNull && !_unknownValuesWarned.Contains(null))
+            {
+                // We received an empty string and have no mapping for it, and the property isn't nullable
+                _unknownValuesWarned.Add(null!);
+                LibraryHelpers.StaticLogger?.LogWarning($"Received null or empty enum value, but property type is not a nullable enum. EnumType: {typeof(T).FullName}. If you think {typeof(T).FullName} should be nullable please open an issue on the Github repo");
             }
+
+            return GetUndefinedEnumValue();
         }
 
-        private T? ReadNullable(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options, out bool isEmptyString)
+        private T GetUndefinedEnumValue()
         {
-            isEmptyString = false;
-            var enumType = typeof(T);
+            if (_undefinedEnumValue != null)
+                return _undefinedEnumValue.Value;
+
+            var type = typeof(T);
+            if (!Enum.IsDefined(type, -9))
+                _undefinedEnumValue = (T)Enum.ToObject(type, -9);
+            else if (!Enum.IsDefined(type, -99))
+                _undefinedEnumValue = (T)Enum.ToObject(type, -99);
+            else
+                _undefinedEnumValue = (T)Enum.ToObject(type, -999);
+
+            return (T)_undefinedEnumValue;
+        }
+
+        private T? ReadNullable(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options, out bool isEmptyStringOrNull)
+        {
+            isEmptyStringOrNull = false;
             if (_mappingToEnum == null)
                 CreateMapping();
 
+            bool optimisticCheckDone = false;
+            if (RunOptimistic)
+            {
+                var resultOptimistic = GetValueOptimistic(ref reader, ref optimisticCheckDone);
+                if (resultOptimistic != null)
+                    return resultOptimistic.Value;
+            }
+
+            var isNumber = reader.TokenType == JsonTokenType.Number;
             var stringValue = reader.TokenType switch
             {
                 JsonTokenType.String => reader.GetString(),
@@ -154,13 +176,17 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             };
 
             if (stringValue is null)
-                return null;
-
-            if (!GetValue(enumType, stringValue, out var result))
             {
+                isEmptyStringOrNull = true;
+                return null;
+            }
+
+            if (!GetValue(stringValue, optimisticCheckDone, out var result))
+            {
+                // Note: checking this here and before the GetValue seems redundant but it allows enum mapping for empty strings
                 if (string.IsNullOrWhiteSpace(stringValue))
                 {
-                    isEmptyString = true;
+                    isEmptyStringOrNull = true;
                 }
                 else
                 {
@@ -168,13 +194,22 @@ 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.Key}: {m.Value}"))}]. If you think {stringValue} should be added please open an issue on the Github repo");
                     }
                 }
 
                 return null;
             }
 
+            if (optimisticCheckDone)
+            {
+                if (!_notOptimalValuesWarned.Contains(stringValue))
+                {
+                    _notOptimalValuesWarned.Add(stringValue!);
+                    LibraryHelpers.StaticLogger?.LogTrace($"Enum mapping sub-optimal. EnumType: {_enumType.FullName}, Value: {stringValue}, Known values: [{string.Join(", ", _mappingToEnum!.Select(m => $"{m.Key}: {m.Value}"))}]");
+                }
+            }
+
             return result;
         }
 
@@ -185,45 +220,78 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             writer.WriteStringValue(stringValue);
         }
 
-        private static bool GetValue(Type objectType, string value, out T? result)
+        /// <summary>
+        /// Try to get the enum value based on the string value using the Utf8JsonReader's ValueTextEquals method. 
+        /// This is an optimization to avoid string allocations when possible, but can only match case sensitively
+        /// </summary>
+        private static T? GetValueOptimistic(ref Utf8JsonReader reader, ref bool optimisticCheckDone)
         {
-            if (_mappingToEnum != null)
+            if (reader.TokenType != JsonTokenType.String)
+            {
+                optimisticCheckDone = false;
+                return null;
+            }
+
+            if (_mappingToEnum!.Count >= _optimisticValueCountThreshold)
+            {
+                optimisticCheckDone = false;
+                return null;
+            }
+
+            optimisticCheckDone = true;
+            foreach (var item in _mappingToEnum!)
+            {
+                if (reader.ValueTextEquals(item.Key))
+                    return item.Value;
+            }
+
+            return null;
+        }
+
+        private static bool GetValue(string value, bool optimisticCheckDone, out T? result)
+        {
+            if (_mappingToEnum == null)
+                throw new InvalidOperationException("Enum mapping not initialized");
+
+            T? mapping = null;
+            // If we tried the optimistic path first we already know its not case match
+            if (!optimisticCheckDone) 
             {
-                EnumMapping? mapping = null;
                 // Try match on full equals
                 foreach (var item in _mappingToEnum)
                 {
-                    if (item.StringValue.Equals(value, StringComparison.Ordinal))
+                    if (item.Key.Equals(value, StringComparison.Ordinal))
                     {
-                        mapping = item;
+                        mapping = item.Value;
                         break;
                     }
                 }
+            }
 
-                // If not found, try matching ignoring case
-                if (mapping == null)
+            // If not found, try matching ignoring case
+            if (mapping == null)
+            {
+                foreach (var item in _mappingToEnum)
                 {
-                    foreach (var item in _mappingToEnum)
+                    if (item.Key.Equals(value, StringComparison.OrdinalIgnoreCase))
                     {
-                        if (item.StringValue.Equals(value, StringComparison.OrdinalIgnoreCase))
-                        {
-                            mapping = item;
-                            break;
-                        }
+                        mapping = item.Value;
+                        break;
                     }
                 }
-
-                if (mapping != null)
-                {
-                    result = mapping.Value;
-                    return true;
-                }
             }
 
-            if (objectType.IsDefined(typeof(FlagsAttribute)))
+            if (mapping != null)
+            {
+                result = mapping;
+                return true;
+            }
+            
+
+            if (_hasFlagsAttribute)
             {
                 var intValue = int.Parse(value);
-                result = (T)Enum.ToObject(objectType, intValue);
+                result = (T)Enum.ToObject(_enumType, intValue);
                 return true;
             }
 
@@ -245,7 +313,17 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             try
             {
                 // If no explicit mapping is found try to parse string
-                result = (T)Enum.Parse(objectType, value, true);
+#if NET8_0_OR_GREATER
+                result = Enum.Parse<T>(value, true);
+#else
+                result = (T)Enum.Parse(_enumType, value, true);
+#endif
+                if (!Enum.IsDefined(_enumType, result))
+                {
+                    result = default;
+                    return false;
+                }
+
                 return true;
             }
             catch (Exception)
@@ -257,35 +335,43 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 
         private static void CreateMapping()
         {
-            var mappingToEnum = new List<EnumMapping>();
-            var mappingToString = new Dictionary<T, string>();
+            var mappingStringToEnum = new Dictionary<string, T>();
+            var mappingEnumToString = new Dictionary<T, string>();
 
-            var enumType = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
-            var enumMembers = enumType.GetFields();
+#pragma warning disable IL2080
+            var enumMembers = _enumType.GetFields(BindingFlags.Public | BindingFlags.Static);
+#pragma warning restore IL2080
             foreach (var member in enumMembers)
             {
+                var enumVal = (T)member.GetValue(null)!;
                 var maps = member.GetCustomAttributes(typeof(MapAttribute), false);
                 foreach (MapAttribute attribute in maps)
                 {
                     foreach (var value in attribute.Values)
                     {
-                        var enumVal = (T)Enum.Parse(enumType, member.Name);
-                        mappingToEnum.Add(new EnumMapping(enumVal, value));
-                        if (!mappingToString.ContainsKey(enumVal))
-                            mappingToString.Add(enumVal, value);
+                        mappingStringToEnum.Add(value, enumVal);
+                        if (!mappingEnumToString.ContainsKey(enumVal))
+                            mappingEnumToString.Add(enumVal, value);
                     }
                 }
             }
 
 #if NET8_0_OR_GREATER
-            _mappingToEnum = mappingToEnum.ToFrozenSet();
-            _mappingToString = mappingToString.ToFrozenDictionary();
+            _mappingToEnum = mappingStringToEnum.ToFrozenDictionary();
+            _mappingToString = mappingEnumToString.ToFrozenDictionary();
 #else
-            _mappingToEnum = mappingToEnum;
-            _mappingToString = mappingToString;
+            _mappingToEnum = mappingStringToEnum;
+            _mappingToString = mappingEnumToString;
 #endif
         }
 
+        // For testing purposes only, allows resetting the static mapping and warnings
+        internal static void Reset()
+        {
+            _undefinedEnumValue = null;
+            _unknownValuesWarned = new ConcurrentBag<string>();
+        }
+
         /// <summary>
         /// Get the string value for an enum value using the MapAttribute mapping. When multiple values are mapped for a enum entry the first value will be returned
         /// </summary>
@@ -307,41 +393,30 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         /// <returns></returns>
         public static T? ParseString(string value)
         {
-            var type = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
             if (_mappingToEnum == null)
                 CreateMapping();
 
-            EnumMapping? mapping = null;
             // Try match on full equals
             foreach(var item in _mappingToEnum!)
             {
-                if (item.StringValue.Equals(value, StringComparison.Ordinal))
-                {
-                    mapping = item;
-                    break;
-                }
+                if (item.Key.Equals(value, StringComparison.Ordinal))
+                    return item.Value;
             }
 
             // If not found, try matching ignoring case
-            if (mapping == null)
+            foreach (var item in _mappingToEnum)
             {
-                foreach (var item in _mappingToEnum)
-                {
-                    if (item.StringValue.Equals(value, StringComparison.OrdinalIgnoreCase))
-                    {
-                        mapping = item;
-                        break;
-                    }
-                }
+                if (item.Key.Equals(value, StringComparison.OrdinalIgnoreCase))
+                    return item.Value;
             }
 
-            if (mapping != null)
-                return mapping.Value;
-
             try
             {
-                // If no explicit mapping is found try to parse string
-                return (T)Enum.Parse(type, value, true);
+#if NET8_0_OR_GREATER
+                return Enum.Parse<T>(value, true);
+#else
+                return (T)Enum.Parse(_enumType, value, true);
+#endif
             }
             catch (Exception)
             {

CryptoExchange.Net/Converters/SystemTextJson/MessageHandlers/JsonRestMessageHandler.cs

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

CryptoExchange.Net/Converters/SystemTextJson/MessageHandlers/JsonSocketMessageHandler.cs

@@ -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())
             {

CryptoExchange.Net/Converters/SystemTextJson/ObjectStringConverter.cs

@@ -24,7 +24,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             if (string.IsNullOrEmpty(value))
                 return default;
 
-            return (T?)JsonDocument.Parse(value!).Deserialize(typeof(T), options);
+            return JsonDocument.Parse(value!).Deserialize<T>(options);
         }
 
         /// <inheritdoc />

CryptoExchange.Net/Converters/SystemTextJson/SharedQuantityConverter.cs

@@ -13,7 +13,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
             if (reader.TokenType != JsonTokenType.StartArray)
-                throw new Exception("");
+                throw new Exception("Invalid JSON structure");
 
             reader.Read(); // Start array
             var baseQuantity = reader.TokenType == JsonTokenType.Null ? (decimal?)null : reader.GetDecimal();
@@ -24,7 +24,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             reader.Read();
 
             if (reader.TokenType != JsonTokenType.EndArray)
-                throw new Exception("");
+                throw new Exception("Invalid JSON structure");
 
             reader.Read(); // End array
 

CryptoExchange.Net/Converters/SystemTextJson/SharedSymbolConverter.cs

@@ -10,7 +10,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         public override SharedSymbol? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
             if (reader.TokenType != JsonTokenType.StartArray)
-                throw new Exception("");
+                throw new Exception("Invalid JSON structure");
 
             reader.Read(); // Start array
             var tradingMode = (TradingMode)Enum.Parse(typeof(TradingMode), reader.GetString()!);
@@ -24,7 +24,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             reader.Read();
 
             if (reader.TokenType != JsonTokenType.EndArray)
-                throw new Exception("");
+                throw new Exception("Invalid JSON structure");
 
             reader.Read(); // End array
 

CryptoExchange.Net/Converters/SystemTextJson/SystemTextJsonMessageAccessor.cs

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

CryptoExchange.Net/CryptoExchange.Net.csproj

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

CryptoExchange.Net/ExchangeHelpers.cs

@@ -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>
@@ -500,5 +531,50 @@ namespace CryptoExchange.Net
             // Unknown decimal format, return null
             return null;
         }
+
+        /// <summary>
+        /// Convert byte array to hex string
+        /// </summary>
+        /// <param name="buff"></param>
+        /// <returns></returns>
+        public static string BytesToHexString(byte[] buff)
+            => BytesToHexString(new ArraySegment<byte>(buff));
+
+        /// <summary>
+        /// Convert byte array to hex string
+        /// </summary>
+        /// <param name="buff"></param>
+        /// <returns></returns>
+        public static string BytesToHexString(ArraySegment<byte> buff)
+        {
+#if NET9_0_OR_GREATER
+            return Convert.ToHexString(buff);
+#else
+            var result = string.Empty;
+            foreach (var t in buff)
+                result += t.ToString("X2");
+            return result;
+#endif
+        }
+
+        /// <summary>
+        /// Convert a hex encoded string to byte array
+        /// </summary>
+        /// <param name="hexString"></param>
+        /// <returns></returns>
+        public static byte[] HexToBytesString(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;
+        }
     }
 }

CryptoExchange.Net/ExchangeSymbolCache.cs

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

CryptoExchange.Net/ExtensionMethods.cs

@@ -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 (Array)parameter.Value)
                         {
+                            if (!firstArrayValue)
+                                uriString.Append('&');
+                            firstArrayValue = false;
+
                             uriString.Append(parameter.Key);
                             uriString.Append("[]=");
                             if (urlEncodeValues)
@@ -86,8 +91,12 @@ namespace CryptoExchange.Net
                     }
                     else if (serializationType == ArrayParametersSerialization.MultipleValues)
                     {
-                        foreach (var entry in (object[])parameter.Value)
+                        bool firstArrayValue = true;
+                        foreach (var entry in (Array)parameter.Value)
                         {
+                            if (!firstArrayValue)
+                                uriString.Append('&');
+                            firstArrayValue = false;
                             uriString.Append(parameter.Key);
                             uriString.Append("=");
                             if (urlEncodeValues)
@@ -98,9 +107,9 @@ namespace CryptoExchange.Net
                     }
                     else
                     {
-                        uriString.Append('[');
+                        uriString.Append($"{parameter.Key}=[");
                         var firstArrayEntry = true;
-                        foreach (var entry in (object[])parameter.Value)
+                        foreach (var entry in (Array)parameter.Value)
                         {
                             if (!firstArrayEntry)
                                 uriString.Append(',');                            
@@ -283,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>
@@ -410,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>
@@ -436,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>
@@ -607,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;
+        }
     }
 }
 

CryptoExchange.Net/Interfaces/Clients/IBaseApiClient.cs

@@ -15,11 +15,6 @@ namespace CryptoExchange.Net.Interfaces.Clients
         /// </summary>
         string BaseAddress { get; }
 
-        /// <summary>
-        /// Whether or not API credentials have been configured for this client. Does not check the credentials are actually valid.
-        /// </summary>
-        bool Authenticated { get; }
-
         /// <summary>
         /// Format a base and quote asset to an exchange accepted symbol 
         /// </summary>
@@ -29,19 +24,5 @@ namespace CryptoExchange.Net.Interfaces.Clients
         /// <param name="deliverDate">The deliver date for a delivery futures symbol</param>
         /// <returns></returns>
         string FormatSymbol(string baseAsset, string quoteAsset, TradingMode tradingMode, DateTime? deliverDate = null);
-
-        /// <summary>
-        /// Set the API credentials for this API client
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="credentials"></param>
-        void SetApiCredentials<T>(T credentials) where T : ApiCredentials;
-
-        /// <summary>
-        /// Set new options. Note that when using a proxy this should be provided in the options even when already set before or it will be reset.
-        /// </summary>
-        /// <typeparam name="T">Api credentials type</typeparam>
-        /// <param name="options">Options to set</param>
-        void SetOptions<T>(UpdateOptions<T> options) where T : ApiCredentials;
     }
 }

CryptoExchange.Net/Interfaces/Clients/ICryptoRestClient.cs

@@ -1,17 +0,0 @@
-using System;
-
-namespace CryptoExchange.Net.Interfaces.Clients
-{
-    /// <summary>
-    /// Client for accessing REST API's for different exchanges
-    /// </summary>
-    public interface ICryptoRestClient
-    {
-        /// <summary>
-        /// Try get 
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <returns></returns>
-        T TryGet<T>(Func<T> createFunc);
-    }
-}

CryptoExchange.Net/Interfaces/Clients/ICryptoSocketClient.cs

@@ -1,17 +0,0 @@
-using System;
-
-namespace CryptoExchange.Net.Interfaces.Clients
-{
-    /// <summary>
-    /// Client for accessing Websocket API's for different exchanges
-    /// </summary>
-    public interface ICryptoSocketClient
-    {
-        /// <summary>
-        /// Try get a client by type for the service collection
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <returns></returns>
-        T TryGet<T>(Func<T> createFunc);
-    }
-}

CryptoExchange.Net/Interfaces/Clients/IRestApiClient.cs

@@ -1,4 +1,7 @@
-namespace CryptoExchange.Net.Interfaces.Clients
+using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Objects.Options;
+
+namespace CryptoExchange.Net.Interfaces.Clients
 {
     /// <summary>
     /// Base rest API client
@@ -15,4 +18,25 @@
         /// </summary>
         int TotalRequestsMade { get; set; }
     }
+
+    /// <inheritdoc />
+    public interface IRestApiClient<TApiCredentials> : IRestApiClient
+        where TApiCredentials : ApiCredentials
+    {
+        /// <summary>
+        /// Whether or not API credentials have been configured for this client. Does not check the credentials are actually valid.
+        /// </summary>
+        bool Authenticated { get; }
+
+        /// <summary>
+        /// Set the API credentials for this API client
+        /// </summary>
+        void SetApiCredentials(TApiCredentials credentials);
+
+        /// <summary>
+        /// Set new options. Note that when using a proxy this should be provided in the options even when already set before or it will be reset.
+        /// </summary>
+        /// <param name="options">Options to set</param>
+        void SetOptions(UpdateOptions<TApiCredentials> options);
+    }
 }

CryptoExchange.Net/Interfaces/Clients/IRestClient.cs

@@ -1,4 +1,5 @@
 using System;
+using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Objects.Options;
 
 namespace CryptoExchange.Net.Interfaces.Clients
@@ -6,7 +7,7 @@ namespace CryptoExchange.Net.Interfaces.Clients
     /// <summary>
     /// Base class for rest API implementations
     /// </summary>
-    public interface IRestClient: IDisposable
+    public interface IRestClient : IDisposable
     {
         /// <summary>
         /// The options provided for this client
@@ -22,5 +23,32 @@ namespace CryptoExchange.Net.Interfaces.Clients
         /// The exchange name
         /// </summary>
         string Exchange { get; }
+
+        /// <summary>
+        /// Whether client is disposed
+        /// </summary>
+        bool Disposed { get; }
+
+        /// <summary>
+        /// Update specific options
+        /// </summary>
+        /// <param name="options">Options to update. Only specific options are changeable after the client has been created</param>
+        void SetOptions(UpdateOptions options);
+    }
+
+    /// <inheritdoc />
+    public interface IRestClient<TApiCredentials> : IRestClient where TApiCredentials : ApiCredentials
+    {
+        /// <summary>
+        /// Set the API credentials for this client. All Api clients in this client will use the new credentials, regardless of earlier set options.
+        /// </summary>
+        /// <param name="credentials">The credentials to set</param>
+        void SetApiCredentials(TApiCredentials credentials);
+
+        /// <summary>
+        /// Update specific options
+        /// </summary>
+        /// <param name="options">Options to update. Only specific options are changeable after the client has been created</param>
+        void SetOptions(UpdateOptions<TApiCredentials> options);
     }
 }

CryptoExchange.Net/Interfaces/Clients/ISocketApiClient.cs

@@ -1,4 +1,5 @@
-using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.Sockets.Default.Interfaces;
@@ -10,7 +11,7 @@ namespace CryptoExchange.Net.Interfaces.Clients
     /// <summary>
     /// Socket API client
     /// </summary>
-    public interface ISocketApiClient: IBaseApiClient
+    public interface ISocketApiClient : IBaseApiClient
     {
         /// <summary>
         /// The current amount of socket connections on the API client
@@ -73,4 +74,25 @@ namespace CryptoExchange.Net.Interfaces.Clients
         /// <returns></returns>
         Task<CallResult> PrepareConnectionsAsync();
     }
+
+    /// <inheritdoc />
+    public interface ISocketApiClient<TApiCredentials> : ISocketApiClient
+        where TApiCredentials : ApiCredentials
+    {
+
+        /// <summary>
+        /// Whether or not API credentials have been configured for this client. Does not check the credentials are actually valid.
+        /// </summary>
+        bool Authenticated { get; }
+        /// <summary>
+        /// Set the API credentials for this API client
+        /// </summary>
+        void SetApiCredentials(TApiCredentials credentials);
+
+        /// <summary>
+        /// Set new options. Note that when using a proxy this should be provided in the options even when already set before or it will be reset.
+        /// </summary>
+        /// <param name="options">Options to set</param>
+        void SetOptions(UpdateOptions<TApiCredentials> options);
+    }
 }

CryptoExchange.Net/Interfaces/Clients/ISocketClient.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.Objects.Sockets;
 
@@ -8,7 +9,7 @@ namespace CryptoExchange.Net.Interfaces.Clients
     /// <summary>
     /// Base class for socket API implementations
     /// </summary>
-    public interface ISocketClient: IDisposable
+    public interface ISocketClient : IDisposable
     {
         /// <summary>
         /// The exchange name
@@ -35,6 +36,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>
@@ -54,5 +60,28 @@ namespace CryptoExchange.Net.Interfaces.Clients
         /// </summary>
         /// <returns></returns>
         Task UnsubscribeAllAsync();
+
+        /// <summary>
+        /// Update specific options
+        /// </summary>
+        /// <param name="options">Options to update. Only specific options are changeable after the client has been created</param>
+        void SetOptions(UpdateOptions options);
+    }
+
+    /// <inheritdoc />
+    public interface ISocketClient<TApiCredentials> : ISocketClient where TApiCredentials : ApiCredentials
+    {
+
+        /// <summary>
+        /// Set the API credentials for this client. All Api clients in this client will use the new credentials, regardless of earlier set options.
+        /// </summary>
+        /// <param name="credentials">The credentials to set</param>
+        void SetApiCredentials(TApiCredentials credentials);
+
+        /// <summary>
+        /// Update specific options
+        /// </summary>
+        /// <param name="options">Options to update. Only specific options are changeable after the client has been created</param>
+        void SetOptions(UpdateOptions<TApiCredentials> options);
     }
 }

CryptoExchange.Net/Interfaces/IMessageAccessor.cs

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

CryptoExchange.Net/Interfaces/IRequest.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -43,9 +44,7 @@ namespace CryptoExchange.Net.Interfaces
         /// <summary>
         /// Set string content
         /// </summary>
-        /// <param name="data"></param>
-        /// <param name="contentType"></param>
-        void SetContent(string data, string contentType);
+        void SetContent(string data, Encoding? encoding, string contentType);
 
         /// <summary>
         /// Add a header to the request

CryptoExchange.Net/Interfaces/IRequestFactory.cs

@@ -1,4 +1,5 @@
-using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Options;
 using System;
 using System.Net.Http;

CryptoExchange.Net/LibraryHelpers.cs

@@ -1,4 +1,6 @@
-using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Options;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
@@ -19,7 +21,7 @@ namespace CryptoExchange.Net
         public static ILogger? StaticLogger
         {
             get => _staticLogger;
-            internal set  
+            internal set
             {
                 if (_staticLogger != null)
                     return;
@@ -53,6 +55,7 @@ namespace CryptoExchange.Net
             { "Kucoin.SpotKey", "f8ae62cb-2b3d-420c-8c98-e1c17dd4e30a" },
             { "Mexc", "EASYT" },
             { "OKX", "1425d83a94fbBCDE" },
+            { "Weex", "b-WEEX111124-" },
             { "XT", "4XWeqN10M1fcoI5L" },
         };
 
@@ -105,31 +108,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 +151,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;

CryptoExchange.Net/Logging/Extensions/RestApiClientLoggingExtensions.cs

@@ -22,7 +22,6 @@ namespace CryptoExchange.Net.Logging.Extensions
         private static readonly Action<ILogger, string, Exception?> _restApiCacheHit;
         private static readonly Action<ILogger, string, Exception?> _restApiCacheNotHit;
         private static readonly Action<ILogger, int?, Exception?> _restApiCancellationRequested;
-        private static readonly Action<ILogger, int?, string?, Exception?> _restApiReceivedResponse;
 
         static RestApiClientLoggingExtensions()
         {
@@ -90,11 +89,6 @@ namespace CryptoExchange.Net.Logging.Extensions
                 LogLevel.Debug,
                 new EventId(4012, "RestApiCancellationRequested"),
                 "[Req {RequestId}] Request cancelled by user");
-
-            _restApiReceivedResponse = LoggerMessage.Define<int?, string?>(
-                LogLevel.Trace,
-                new EventId(4013, "RestApiReceivedResponse"),
-                "[Req {RequestId}] Received response: {Data}");
             
         }
 
@@ -161,10 +155,5 @@ namespace CryptoExchange.Net.Logging.Extensions
         {
             _restApiCancellationRequested(logger, requestId, null);
         }
-
-        public static void RestApiReceivedResponse(this ILogger logger, int requestId, string? originalData)
-        {
-            _restApiReceivedResponse(logger, requestId, originalData, null);
-        }
     }
 }

CryptoExchange.Net/Logging/Extensions/SocketConnectionLoggingExtension.cs

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