Merge branch 'master' into feature/shared-apis-v2

.cursor/rules/cryptoexchange-net.mdc

@@ -1,92 +1,87 @@
 ---
-description: Conventions for cross-exchange C# code using CryptoExchange.Net Shared API V2 capabilities.
+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
+# CryptoExchange.Net Conventions
 
-CryptoExchange.Net is the base dependency for exchange-specific libraries. Install Binance.Net, Bybit.Net, JK.OKX.Net, or another exchange library; use `CryptoClients.Net` when the application needs the bundle.
+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.
 
-## Use Shared API V2
-
-For new cross-exchange code, use the fine-grained interfaces in `CryptoExchange.Net.SharedApis` and each API surface's `.SharedApi` property:
+## Multi-exchange pattern
 
 ```csharp
+using Binance.Net.Clients;
+using OKX.Net.Clients;
 using CryptoExchange.Net.SharedApis;
 
-IGetTickerRest binance = new BinanceRestClient().SpotApi.SharedApi;
-IGetTickerRest okx = new OKXRestClient().UnifiedApi.SharedApi;
+ISpotTickerRestClient binance = new BinanceRestClient().SpotApi.SharedClient;
+ISpotTickerRestClient okx     = new OKXRestClient().UnifiedApi.SharedClient;
 
 var symbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
-var result = await binance.GetTickerAsync(new GetTickerRequest(symbol));
+
+var ticker = await binance.GetSpotTickerAsync(new GetTickerRequest(symbol));
+// ticker.Data.LastPrice — same model regardless of exchange
 ```
 
-Use one capability per operation, such as `IGetTickerRest`, `IGetOrderBookRest`, `IPlaceSpotOrderRest`, or `ISubscribeTradesSocket`. Do not use a broad V1 interface for new code. `.SharedClient` remains only for incremental V1 migration.
+## Symbol normalization
 
-## Capability discovery
+`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.
 
-When the exchange and API surface are known, assign the typed `.SharedApi` to the required capability. When selection is dynamic, use an exchange-wide `I[Exchange]SharedApiClient` and a strongly typed reference:
+## Symbol metadata and catalogs
+
+In 12.2.0, `SharedSpotSymbol` and `SharedFuturesSymbol` include `DisplayName` and base/quote asset classification through `SharedAssetType` (`Crypto`, `Fiat`, `TradFi`) and `SharedAssetSubType` (`StableCoin`, `Equity`, `Commodity`). Pass the matching base/quote filters to `GetSymbolsRequest` when discovery should return only a class of markets.
+
+After calling `GetSpotSymbolsAsync`, `ISpotSymbolRestClient.SpotSymbolCatalog` maps asset and symbol names to shared metadata. `IFuturesSymbolRestClient.FuturesSymbolCatalog` works the same way after `GetFuturesSymbolsAsync`. Treat either property as unavailable before its corresponding request has populated the cache.
+
+When implementing an exchange library, use `LibraryHelpers.IsStableCoin`, `IsCommodity`, and `IsEquity` only as best-effort classifiers and supply exchange-specific additions where needed.
+
+## Shared market-data quantities
+
+In 12.4.0, use `SharedOrderQuantity`-valued `Volumes` on shared spot/futures tickers and klines, and `Quantities` on shared trades. The scalar `Volume`, `QuoteVolume`, and `Quantity` members are obsolete.
+
+## WebSocket order commands
+
+In 12.5.0, `ISpotOrderManagementSocketClient` and `IFuturesOrderManagementSocketClient` optionally provide place/cancel order commands over WebSocket. Their methods return `QueryResult<SharedId>`, not `WebSocketResult<UpdateSubscription>`. Check whether the exchange implements the interface.
+
+## Result pattern
+
+REST methods return `HttpResult<T>` and websocket subscription methods return `WebSocketResult<UpdateSubscription>`. 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, and optional spot/futures order management
+
+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 match = sharedClient.GetCapability(
-    SharedCapabilities.Orders.Futures.PlaceOrder.Rest,
-    TradingMode.PerpetualLinear);
-
-if (match is not null)
-    await match.Capability.PlaceFuturesOrderAsync(request);
-```
-
-`GetCapability` returns one preferred match or `null`; `GetCapabilities` returns all matches. Specify `TradingMode` when multiple API surfaces may implement the same capability. A `SharedCapabilities` reference is a lookup key, not proof of exchange support.
-
-## Symbols and parameters
-
-Use `SharedSymbol` instead of native strings such as `BTCUSDT`. The exchange library performs formatting.
-
-Capability presence does not imply support for every request property. For dynamic code, inspect `match.Options.RequestParameterRules`, `ExchangeParameterRules`, and `SupportedTradingModes`. Supply exchange-specific values through the request's `ExchangeParameters`.
-
-## Transports and results
-
-- Transport-agnostic capabilities return `IExchangeCallResult<T>`.
-- `...Rest` capabilities return `HttpResult<T>`.
-- socket command capabilities return `QueryResult<T>`.
-- `ISubscribe...Socket` capabilities return `WebSocketResult<UpdateSubscription>`.
-
-Use `.Rest` or `.Socket` on capability references when the transport matters. Otherwise exchange-wide lookup honors `PreferredTransport`, normally REST. Always check `.Success` before `.Data` and include `.Exchange` in multi-exchange logs.
-
-## Concurrent aggregation
-
-```csharp
-var clients = new IGetTickerRest[] { binance, okx, bybit };
-var tasks = clients.Select(x =>
-    x.GetTickerAsync(new GetTickerRequest(symbol)));
+var clients = new ISpotTickerRestClient[] { binance, okx, bybit };
+var tasks   = clients.Select(c => c.GetSpotTickerAsync(new GetTickerRequest(symbol)));
 var results = await Task.WhenAll(tasks);
 ```
 
-Reuse clients through dependency injection and run independent exchange calls concurrently.
-
-## V2 semantics
-
-- `GetTickerAsync` and `GetAllTickersAsync` return `SharedTicker` for spot and futures.
-- WebSocket order updates use `SharedSpotOrderUpdate` and `SharedFuturesOrderUpdate`.
-- `ICloseFullPosition` closes the entire position; use an order capability for partial closes.
-- Each exchange supports a subset of capabilities and parameter combinations.
-
 ## Hard rules
 
-- Never install CryptoExchange.Net alone and expect exchange endpoints.
-- Never pass exchange-native models or symbols through shared services.
-- Never assume a capability or request field is supported; resolve and inspect it.
-- Never use `.Result` or `.Wait()`.
-- Never instantiate exchange clients per request.
-- Prefer `Task.WhenAll` for independent cross-exchange calls.
-- Prefer `.SharedApi` and fine-grained V2 interfaces for new code.
+- ❌ 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` for fuller examples
-- `docs/ai-api-map.md` for the V2 interface map
-- `docs/SHARED_API_V2_MIGRATION.md` for V1 migration details
-- `llms-full.txt` for expanded AI context
+- `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

@@ -1,70 +1,66 @@
 # Copilot Instructions for CryptoExchange.Net
 
-CryptoExchange.Net is the base library behind exchange-specific C#/.NET clients such as Binance.Net, Bybit.Net, OKX.Net, Kraken.Net, and Coinbase.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.).
 
-## Package choice
+When generating code in this ecosystem, follow these conventions:
 
-Do not install CryptoExchange.Net alone to call an exchange. Install the exchange-specific package, or use `CryptoClients.Net` for the full bundle. For single-exchange code, prefer that library's native client. For portable multi-exchange code, use `CryptoExchange.Net.SharedApis`.
+## You don't install CryptoExchange.Net directly
 
-## Generate Shared API V2 code
+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.
 
-Use fine-grained V2 capabilities through `.SharedApi`:
+## 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;
 
-IGetTickerRest binance = new BinanceRestClient().SpotApi.SharedApi;
-IGetTickerRest okx = new OKXRestClient().UnifiedApi.SharedApi;
+ISpotTickerRestClient binance = new BinanceRestClient().SpotApi.SharedClient;
+ISpotTickerRestClient okx     = new OKXRestClient().UnifiedApi.SharedClient;
 
 var symbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
-var result = await binance.GetTickerAsync(new GetTickerRequest(symbol));
+var ticker = await binance.GetSpotTickerAsync(new GetTickerRequest(symbol));
 ```
 
-Choose the interface for the operation: for example, `IGetTickerRest`, `IGetOrderBookRest`, `IPlaceSpotOrderRest`, `ICancelFuturesOrderRest`, or `ISubscribeTradesSocket`. V1 broad interfaces remain on `.SharedClient` for migration, but new code should use `.SharedApi`.
+Same code works on every exchange that implements the interface. Use `Task.WhenAll` for concurrent multi-exchange calls.
 
-Use `SharedSymbol`; do not hard-code exchange-native symbol formatting in shared code.
+## Shared symbol metadata
 
-## Runtime capability selection
+CryptoExchange.Net 12.2.0 classifies the base and quote sides of `SharedSpotSymbol` and `SharedFuturesSymbol` with `SharedAssetType` (`Crypto`, `Fiat`, `TradFi`) and optional `SharedAssetSubType` (`StableCoin`, `Equity`, `Commodity`). The models also expose `DisplayName`. Use the corresponding base/quote fields on `GetSymbolsRequest` to filter symbol discovery.
 
-When the API surface is known, assign its typed `.SharedApi` directly. When support or the API surface is selected at runtime, use the exchange-wide `I[Exchange]SharedApiClient`:
+`ISpotSymbolRestClient.SpotSymbolCatalog` is populated by `GetSpotSymbolsAsync`; `IFuturesSymbolRestClient.FuturesSymbolCatalog` is populated by `GetFuturesSymbolsAsync`. Do not assume a catalog is available before that request. For exchange-library implementations, `LibraryHelpers.IsStableCoin`, `IsCommodity`, and `IsEquity` offer best-effort classification and can be extended with exchange-specific values.
 
-```csharp
-var match = sharedClient.GetCapability(
-    SharedCapabilities.Orders.Futures.PlaceOrder.Rest,
-    TradingMode.PerpetualLinear);
+## Shared market-data quantities
 
-if (match is null)
-    return;
+CryptoExchange.Net 12.4.0 uses `SharedOrderQuantity` for market-data quantities. Prefer `Volumes` on `SharedSpotTicker`, `SharedFuturesTicker`, and `SharedKline`, and `Quantities` on `SharedTrade`; the scalar `Volume`, `QuoteVolume`, and `Quantity` members are obsolete.
 
-var result = await match.Capability.PlaceFuturesOrderAsync(request);
-```
+## WebSocket order commands
 
-`GetCapability` returns one preferred `SharedCapabilityResolution<T>` or `null`; `GetCapabilities` returns all matching implementations. Include `TradingMode` when an exchange can expose multiple futures surfaces. `SharedCapabilities` entries are lookup references, not guarantees of support.
+CryptoExchange.Net 12.5.0 adds optional `ISpotOrderManagementSocketClient` and `IFuturesOrderManagementSocketClient` interfaces for placing and canceling orders over WebSocket. These command methods return `QueryResult<SharedId>` rather than a subscription result. Check exchange support before relying on either interface.
 
-Before constructing dynamic requests, inspect `match.Options.RequestParameterRules`, `ExchangeParameterRules`, and `SupportedTradingModes`. A capability may exist while a particular request field is unsupported.
+## Single-exchange code uses the exchange's own client
 
-## Results and transports
+For Binance-only code, use `BinanceRestClient` directly (see Binance.Net repo `AGENTS.md`). SharedApis is for portability — use it when you need that.
 
-- Transport-agnostic operation: `IExchangeCallResult<T>`
-- REST capability: `HttpResult<T>`
-- WebSocket command capability: `QueryResult<T>`
-- WebSocket subscription capability: `WebSocketResult<UpdateSubscription>`
+## Result pattern
 
-Select `.Rest` or `.Socket` when transport-specific behavior matters. Otherwise exchange-wide selection uses `PreferredTransport`, normally REST. Always check `.Success` before `.Data`; use `.Error` and `.Exchange` for diagnostics.
+REST methods return `HttpResult<T>` and websocket subscription methods return `WebSocketResult<UpdateSubscription>`. Check `.Success` before `.Data`. `.Error` has structured info. `.Exchange` on shared clients identifies which exchange responded.
 
-## Current V2 semantics
+## Available shared interfaces
 
-- Ticker operations are `GetTickerAsync` and `GetAllTickersAsync`, returning `SharedTicker` for both spot and futures.
-- Socket order streams use `SharedSpotOrderUpdate` and `SharedFuturesOrderUpdate`.
-- `ICloseFullPosition` closes a complete position, not a partial quantity.
-- Exchange support varies by operation, transport, trading mode, and request parameter.
+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, and optional spot/futures order management.
 
-## Engineering conventions
+Each exchange library implements a subset. Check exchange docs for support matrix.
 
-- Reuse clients through dependency injection.
-- Use `await`; never use `.Result` or `.Wait()`.
-- Use `Task.WhenAll` for independent requests across exchanges.
-- Keep exchange-native models out of portable services.
-- Do not infer feature support from a broad interface or request model.
+## Avoid
 
-See `AGENTS.md`, `docs/ai-api-map.md`, and `docs/SHARED_API_V2_MIGRATION.md` for expanded guidance.
+- 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

@@ -1,39 +1,40 @@
 ---
 name: cryptoexchange-net
-description: Use CryptoExchange.Net Shared API V2 abstractions when generating C#/.NET code for multiple cryptocurrency exchanges, including arbitrage, routing, portfolio aggregation, exchange-agnostic bots, comparison tools, and new exchange-library implementations.
+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 behind exchange-specific libraries such as Binance.Net, Bybit.Net, OKX.Net, Kraken.Net, and Coinbase.Net. Do not install it alone to call an exchange.
+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.
 
-Choose one of these approaches:
+**Three usage modes:**
 
-1. One exchange: install and use that exchange's library directly.
-2. Multiple exchanges: install the required exchange libraries and use `CryptoExchange.Net.SharedApis` V2 capabilities.
-3. All exchanges in one package: install `CryptoClients.Net` and use its combined clients and shared capability lookup.
-
-For new cross-exchange code, use Shared API V2. V1 aggregate interfaces remain available through `.SharedClient` for incremental migration.
+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 install the bundle:
+Or the bundle:
 
 ```bash
 dotnet add package CryptoClients.Net
 ```
 
-## Core pattern: fine-grained capabilities
+## Core Pattern: Shared Interfaces
 
-Each exchange API surface exposes a typed `.SharedApi` aggregate. Assign it to the capability for the single operation being used:
+Every exchange library exposes `.SharedClient` properties on its API surfaces. These implement the same interfaces from `CryptoExchange.Net.SharedApis`.
 
 ```csharp
 using Binance.Net.Clients;
@@ -41,187 +42,155 @@ using OKX.Net.Clients;
 using Bybit.Net.Clients;
 using CryptoExchange.Net.SharedApis;
 
-IGetTickerRest binance = new BinanceRestClient().SpotApi.SharedApi;
-IGetTickerRest okx = new OKXRestClient().UnifiedApi.SharedApi;
-IGetTickerRest bybit = new BybitRestClient().V5Api.SharedApi;
+// 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 result = await binance.GetTickerAsync(new GetTickerRequest(symbol));
+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.
+
+## Symbol Metadata and Asset Classification
+
+Since CryptoExchange.Net 12.2.0, shared symbol responses describe both sides of a market with `BaseAssetType`, `BaseAssetSubType`, `QuoteAssetType`, and `QuoteAssetSubType`. `SharedAssetType` distinguishes `Crypto`, `Fiat`, and `TradFi`; `SharedAssetSubType` distinguishes `StableCoin`, `Equity`, and `Commodity`. `SharedSpotSymbol` and `SharedFuturesSymbol` also expose `DisplayName`.
+
+The same fields on `GetSymbolsRequest` filter spot or futures symbol discovery:
+
+```csharp
+var request = new GetSymbolsRequest(
+    baseAssetType: SharedAssetType.Crypto,
+    quoteAssetSubType: SharedAssetSubType.StableCoin);
+
+var result = await symbolClient.GetSpotSymbolsAsync(request);
+```
+
+After calling `GetSpotSymbolsAsync` or `GetFuturesSymbolsAsync`, use the client's `SpotSymbolCatalog` or `FuturesSymbolCatalog` to look up normalized asset and symbol metadata by name. The catalog is unavailable until the corresponding symbol request has populated the cache.
+
+For exchange-library implementations, `LibraryHelpers.IsStableCoin`, `IsCommodity`, and `IsEquity` provide best-effort classification of known assets and accept exchange-specific additions. These helpers are heuristics, not an exhaustive source of truth.
+
+## Shared Market-Data Quantities
+
+Since CryptoExchange.Net 12.4.0, shared market-data models use `SharedOrderQuantity` so base-asset, quote-asset, and contract quantities remain explicit. Read `SharedSpotTicker.Volumes`, `SharedFuturesTicker.Volumes`, and `SharedKline.Volumes`; read `SharedTrade.Quantities`. The former scalar `Volume`, `QuoteVolume`, and `Quantity` members are obsolete.
+
+## WebSocket Order Management
+
+Since CryptoExchange.Net 12.5.0, exchanges can implement `ISpotOrderManagementSocketClient` and `IFuturesOrderManagementSocketClient` to place and cancel orders over WebSocket. These are command interfaces, not subscription interfaces: `Place*OrderAsync` and `Cancel*OrderAsync` return `QueryResult<SharedId>`. Check exchange support before using them.
+
+## 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`
+- Order commands: `ISpotOrderManagementSocketClient`, `IFuturesOrderManagementSocketClient`
+
+Each exchange documents which interfaces it implements (some exchanges don't support every operation).
+
+## Core Pattern: Result Handling
+
+Same as exchange-specific libraries: REST calls return `HttpResult<T>` and websocket subscription calls return `WebSocketResult<UpdateSubscription>`, both with `.Success`, `.Data`, and `.Error`. Always check `.Success` first.
+
+```csharp
+var result = await sharedClient.GetSpotTickerAsync(new GetTickerRequest(symbol));
 if (!result.Success)
-    Console.WriteLine($"[{result.Exchange}] {result.Error}");
-else
-    Console.WriteLine($"[{result.Exchange}] {result.Data!.LastPrice}");
+{
+    Console.WriteLine($"[{sharedClient.Exchange}] Error: {result.Error}");
+    return;
+}
+Console.WriteLine($"[{sharedClient.Exchange}] {result.Data.LastPrice}");
 ```
 
-V2 interfaces describe operations, not broad feature groups. Examples include `IGetTickerRest`, `IGetOrderBookRest`, `IPlaceSpotOrderRest`, `ICancelFuturesOrderRest`, and `ISubscribeTradesSocket`. An exchange may implement one operation without implementing adjacent operations.
+`.Exchange` property on every shared client tells you which exchange you're talking to — useful for logging.
 
-## Shared symbols
-
-Use `SharedSymbol`; never pass exchange-native symbol strings to shared requests:
+## Core Pattern: Multi-Exchange Aggregation
 
 ```csharp
-var spot = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
-var linearPerpetual = new SharedSymbol(
-    TradingMode.PerpetualLinear,
-    "BTC",
-    "USDT");
-```
+var clients = new ISpotTickerRestClient[]
+{
+    new BinanceRestClient().SpotApi.SharedClient,
+    new OKXRestClient().UnifiedApi.SharedClient,
+    new BybitRestClient().V5Api.SharedClient,
+};
 
-Each exchange library converts the shared symbol to its native format. For unusual exchange asset names, configure asset aliases.
-
-## Known surface versus runtime selection
-
-Use the typed `.SharedApi` surface when the exchange and API are known. This is the simplest and most discoverable approach:
-
-```csharp
-IPlaceSpotOrderRest orders = restClient.SpotApi.SharedApi;
-```
-
-For runtime selection, inject the exchange-wide `I[Exchange]SharedApiClient` registered by `services.Add[Exchange](...)`. Resolve a capability with the strongly typed `SharedCapabilities` catalog:
-
-```csharp
-var match = sharedClient.GetCapability(
-    SharedCapabilities.Orders.Futures.PlaceOrder.Rest,
-    TradingMode.PerpetualLinear);
-
-if (match is null)
-    return; // This exchange/API/mode does not provide the operation.
-
-var result = await match.Capability.PlaceFuturesOrderAsync(request);
-```
-
-`GetCapability` returns one `SharedCapabilityResolution<T>` containing `Capability` and `Options`, or `null` if no supported implementation matches. `GetCapabilities` returns every match on that exchange-wide client. Always specify `TradingMode` when multiple spot, linear, inverse, or delivery surfaces could match.
-
-`SharedCapabilities` references identify interface types; they do not guarantee that an exchange implements the operation and do not send a request.
-
-## Transport selection and result types
-
-Some commands have three interfaces:
-
-- Transport-agnostic, such as `IPlaceSpotOrder`, returns `IExchangeCallResult<T>`.
-- REST-specific, such as `IPlaceSpotOrderRest`, returns `HttpResult<T>`.
-- socket-specific, such as `IPlaceSpotOrderSocket`, returns `QueryResult<T>`.
-
-Socket subscription capabilities such as `ISubscribeTickerSocket` return `WebSocketResult<UpdateSubscription>`.
-
-Use `.Rest` or `.Socket` on a capability reference when transport matters. Without a transport filter, exchange-wide lookup uses `PreferredTransport`, configured through the exchange's `SharedApi.PreferredTransport` option and normally defaulting to REST.
-
-Always check `.Success` before `.Data`. Use `.Error` for failures and the result or capability `.Exchange` value for multi-exchange logging.
-
-## Inspect parameter support
-
-The presence of a capability does not mean every shared request property is accepted by every exchange. Inspect its `CapabilityOptions`:
-
-- `RequestParameterRules`: whether each shared request field is `Required`, `Optional`, or `NotSupported`.
-- `ExchangeParameterRules`: required or optional exchange-specific values supplied through the request's `ExchangeParameters`.
-- `SupportedTradingModes`: the trading modes supported by this implementation.
-
-```csharp
-var match = sharedClient.GetCapability(
-    SharedCapabilities.Orders.Futures.PlaceOrder.Rest,
-    TradingMode.PerpetualLinear);
-
-var leverageRule = match?.Options.RequestParameterRules
-    .FirstOrDefault(x => x.Name == nameof(PlaceFuturesOrderRequest.Leverage));
-```
-
-Do not infer support from the request model alone. Handle a `null` resolution and exchange-specific parameter rules before issuing dynamic trading calls.
-
-## Common capabilities
-
-- Market data: `IGetTickerRest`, `IGetAllTickersRest`, `IGetOrderBookRest`, `IGetKlinesRest`, `IGetRecentTradesRest`; ticker, trade, kline, and order-book socket subscriptions.
-- Trading: fine-grained spot and futures place, edit, cancel, get, open-order, closed-order, and order-update capabilities.
-- Account: balances, positions, user trades, fees, deposits, withdrawals, and transfers.
-- Futures data: funding, open interest, leverage, mark price, and index price capabilities.
-
-Check the typed exchange Shared API surface or use capability lookup instead of assuming universal support.
-
-## Multi-exchange aggregation
-
-Run independent exchange requests concurrently:
-
-```csharp
-var clients = new IGetTickerRest[] { binance, okx, bybit };
 var symbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
 
-var tasks = clients.Select(client =>
-    client.GetTickerAsync(new GetTickerRequest(symbol)));
+// Fetch concurrently from all exchanges
+var tasks = clients.Select(c => c.GetSpotTickerAsync(new GetTickerRequest(symbol))).ToArray();
 var results = await Task.WhenAll(tasks);
 
-foreach (var result in results.Where(x => x.Success))
-    Console.WriteLine($"{result.Exchange}: {result.Data!.LastPrice}");
-```
-
-Reuse clients through dependency injection; do not instantiate them per request.
-
-## Dependency injection
-
-Each exchange library provides `services.Add[Exchange](...)`. Registration includes its native clients, V1 shared interfaces, V2 operation capabilities, and exchange-wide shared client.
-
-Inject a capability directly only when the container has one intended implementation:
-
-```csharp
-public sealed class TickerService(IGetTickerRest ticker)
+for (int i = 0; i < clients.Length; i++)
 {
-    public Task<HttpResult<SharedTicker>> GetAsync(
-        SharedSymbol symbol,
-        CancellationToken ct = default)
-        => ticker.GetTickerAsync(new GetTickerRequest(symbol), ct);
+    if (results[i].Success)
+        Console.WriteLine($"{clients[i].Exchange}: {results[i].Data!.LastPrice}");
 }
 ```
 
-If multiple exchanges or multiple API surfaces register the same capability, inject the exchange-specific shared client and select its typed API property or call `GetCapability`. Plain single-service resolution does not express which implementation you want.
+## Per-Exchange Setup
 
-For the bundle, use `services.AddCryptoClients(...)`. CryptoClients.Net provides `IExchangeSharedApiClient` for capability lookup across exchanges.
+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(...); })`.
 
-## V1 migration
+## Dependency Injection
 
-V1 `.SharedClient` facades and broad interfaces such as `ISpotTickerRestClient` remain available. Migrate one operation at a time:
+Each exchange library has its own `services.AddXxx(...)` extension. They all share the same option-builder pattern. Register only the ones you use:
 
 ```csharp
-// V1
-await restClient.SpotApi.SharedClient.GetSpotTickerAsync(request);
-
-// V2
-await restClient.SpotApi.SharedApi.GetTickerAsync(request);
+services.AddBinance(restOpts => { /*...*/ }, socketOpts => { /*...*/ });
+services.AddOKX(restOpts => { /*...*/ }, socketOpts => { /*...*/ });
+// Inject IBinanceRestClient, IOKXRestClient, etc.
 ```
 
-Important semantic changes:
+For one-package access: `services.AddCryptoClients(...)` from `CryptoClients.Net`.
 
-- V2 ticker methods are `GetTickerAsync` and `GetAllTickersAsync` and return `SharedTicker` for both spot and futures.
-- WebSocket order updates use `SharedSpotOrderUpdate` and `SharedFuturesOrderUpdate`; REST order retrieval keeps the ordinary order models.
-- `ICloseFullPosition` closes the complete position. Use an order capability for partial closes where supported.
-- Transport-agnostic operations return `IExchangeCallResult<T>`; select the REST or socket interface when code needs a transport-specific result.
+## Common Pitfalls — AVOID
 
-See `docs/SHARED_API_V2_MIGRATION.md` for detailed mappings.
+- **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.
 
-## Common pitfalls
+## Implementing a New Exchange Library
 
-- Do not install `CryptoExchange.Net` alone and expect exchange endpoints.
-- Do not use `.SharedClient` for new V2 code; use `.SharedApi` and fine-grained capabilities.
-- Do not mix exchange-native request or response models into cross-exchange services.
-- Do not assume capability presence or request-parameter support; resolve and inspect it.
-- Do not rely on preferred transport when REST or socket semantics matter.
-- Do not block with `.Result` or `.Wait()`; use async calls throughout.
-- Do not query exchanges sequentially when requests are independent.
+If you're building a NEW exchange wrapper following the CryptoExchange.Net pattern (rare but valuable):
 
-## Implementing a new exchange library
+- 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
 
-- Derive API clients from `RestApiClient` and `SocketApiClient`.
-- Follow the exchange credentials and options patterns used by existing libraries.
-- Implement the relevant fine-grained V2 capability interfaces on typed Shared API classes.
-- Publish accurate `CapabilityOptions`, including supported trading modes and request/exchange parameter rules.
-- Register REST/socket Shared APIs and the exchange-wide shared client with the library's DI extension.
-- Retain V1 facades only where compatibility with existing consumers is required.
-
-Use maintained exchange libraries such as Binance.Net and Bybit.Net as implementation references.
+See existing libraries (Binance.Net, Bybit.Net) as reference implementations.
 
 ## Reference
 
 - Source: https://github.com/JKorf/CryptoExchange.Net
 - Documentation: https://cryptoexchange.jkorf.dev/
-- Shared API migration: https://github.com/JKorf/CryptoExchange.Net/blob/master/docs/SHARED_API_V2_MIGRATION.md
-- Bundle: https://github.com/JKorf/CryptoClients.Net
+- 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.UnitTests/ConverterTests/ArrayConverterTests.cs

@@ -62,31 +62,6 @@ namespace CryptoExchange.Net.UnitTests.ConverterTests
             Assert.That(deserialized.Prop8!.Prop31, Is.EqualTo(5));
             Assert.That(deserialized.Prop8.Prop32, Is.EqualTo("101"));
         }
-
-        [TestCase("[\"4.803E-5\",\"9.623e-4\",\"0.0010025\"]", 0.00004803, 0.0009623, 0.0010025)]
-        [TestCase("[\"81251.5\",\"1E+2\",\"-2.5E-3\"]", 81251.5, 100, -0.0025)]
-        [TestCase("[4.803E-5,9.623e-4,0.0010025]", 0.00004803, 0.0009623, 0.0010025)]
-        public void TestArrayConverterDecimalInScientificNotation(string json, decimal expected1, decimal expected2, decimal expected3)
-        {
-            // Some exchanges send small prices as strings in scientific notation, for example the
-            // Kucoin futures kline stream: "candles":["1789830000","4.803E-5","4.807E-5",...]
-            var deserialized = JsonSerializer.Deserialize<TestDecimal>(json);
-
-            Assert.That(deserialized!.Prop1, Is.EqualTo(expected1));
-            Assert.That(deserialized.Prop2, Is.EqualTo(expected2));
-            Assert.That(deserialized.Prop3, Is.EqualTo(expected3));
-        }
-    }
-
-    [JsonConverter(typeof(ArrayConverter<TestDecimal>))]
-    public record TestDecimal
-    {
-        [ArrayProperty(0)]
-        public decimal Prop1 { get; set; }
-        [ArrayProperty(1)]
-        public decimal? Prop2 { get; set; }
-        [ArrayProperty(2)]
-        public decimal Prop3 { get; set; }
     }
 
     [JsonConverter(typeof(ArrayConverter<Test>))]

CryptoExchange.Net.UnitTests/RateLimitTests.cs

@@ -3,7 +3,6 @@ using CryptoExchange.Net.RateLimiting;
 using CryptoExchange.Net.RateLimiting.Filters;
 using CryptoExchange.Net.RateLimiting.Guards;
 using CryptoExchange.Net.RateLimiting.Interfaces;
-using CryptoExchange.Net.RateLimiting.Trackers;
 using CryptoExchange.Net.UnitTests.Implementations;
 using NUnit.Framework;
 using System;
@@ -34,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, "123", 1, RateLimitingBehaviour.Wait, null, 1, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "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, "123", 1, RateLimitingBehaviour.Wait, null, 1, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "123", 1, RateLimitingBehaviour.Wait, null, default);
             Assert.That(!triggered);
         }
 
@@ -59,7 +58,7 @@ namespace CryptoExchange.Net.UnitTests
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "123", 1, RateLimitingBehaviour.Wait, null, 1, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "123", 1, RateLimitingBehaviour.Wait, null, default);
                 bool expected = i == 1 ? expectLimiting ? evnt?.DelayTime > TimeSpan.Zero : evnt == null : evnt == null;
                 Assert.That(expected);
             }
@@ -80,9 +79,9 @@ namespace CryptoExchange.Net.UnitTests
             RateLimitEvent? evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "123", 1, RateLimitingBehaviour.Wait, null, 1, default);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "123", 1, RateLimitingBehaviour.Wait, null, default);
             Assert.That(evnt == null);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "123", 1, RateLimitingBehaviour.Wait, null, 1, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "123", 1, RateLimitingBehaviour.Wait, null, default);
             Assert.That(expectLimiting ? evnt != null : evnt == null);
         }
 
@@ -101,12 +100,12 @@ namespace CryptoExchange.Net.UnitTests
 
             for (var i = 0; i < requests + 1; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "123", 1, RateLimitingBehaviour.Wait, null, 1, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "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, "123", 1, RateLimitingBehaviour.Wait, null, 1, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "123", 1, RateLimitingBehaviour.Wait, null, default);
             Assert.That(!triggered);
         }
 
@@ -124,7 +123,7 @@ namespace CryptoExchange.Net.UnitTests
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "123", 1, RateLimitingBehaviour.Wait, null, 1, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "123", 1, RateLimitingBehaviour.Wait, null, default);
                 bool expected = i == 1 ? expectLimited ? evnt?.DelayTime > TimeSpan.Zero : evnt == null : evnt == null;
                 Assert.That(expected);
             }
@@ -144,7 +143,7 @@ namespace CryptoExchange.Net.UnitTests
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "123", 1, RateLimitingBehaviour.Wait, null, 1, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "123", 1, RateLimitingBehaviour.Wait, null, default);
                 bool expected = i == 1 ? expectLimited ? evnt?.DelayTime > TimeSpan.Zero : evnt == null : evnt == null;
                 Assert.That(expected);
             }
@@ -167,9 +166,9 @@ namespace CryptoExchange.Net.UnitTests
             RateLimitEvent? evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, key1, 1, RateLimitingBehaviour.Wait, null, 1, default);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, key1, 1, RateLimitingBehaviour.Wait, null, default);
             Assert.That(evnt == null);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, key2, 1, RateLimitingBehaviour.Wait, null, 1, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, key2, 1, RateLimitingBehaviour.Wait, null, default);
             Assert.That(expectLimited ? evnt != null : evnt == null);
         }
 
@@ -186,9 +185,9 @@ namespace CryptoExchange.Net.UnitTests
             RateLimitEvent? evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "123", 1, RateLimitingBehaviour.Wait, null, 1, default);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "123", 1, RateLimitingBehaviour.Wait, null, default);
             Assert.That(evnt == null);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, null, 1, RateLimitingBehaviour.Wait, null, 1, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, null, 1, RateLimitingBehaviour.Wait, null, default);
             Assert.That(expectLimited ? evnt != null : evnt == null);
         }
 
@@ -206,9 +205,9 @@ namespace CryptoExchange.Net.UnitTests
             RateLimitEvent? evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "123", 1, RateLimitingBehaviour.Wait, null, 1, default);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "123", 1, RateLimitingBehaviour.Wait, null, default);
             Assert.That(evnt == null);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "123", 1, RateLimitingBehaviour.Wait, null, 1, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "123", 1, RateLimitingBehaviour.Wait, null, default);
             Assert.That(expectLimited ? evnt != null : evnt == null);
         }
 
@@ -223,9 +222,9 @@ namespace CryptoExchange.Net.UnitTests
             RateLimitEvent? evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition(host1, "1", HttpMethod.Get), "123", 1, RateLimitingBehaviour.Wait, null, 1, default);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition(host1, "1", HttpMethod.Get), "123", 1, RateLimitingBehaviour.Wait, null, default);
             Assert.That(evnt == null);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition(host2, "1", HttpMethod.Get), "123", 1, RateLimitingBehaviour.Wait, null, 1, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition(host2, "1", HttpMethod.Get), "123", 1, RateLimitingBehaviour.Wait, null, default);
             Assert.That(expectLimited ? evnt != null : evnt == null);
         }
 
@@ -239,8 +238,8 @@ namespace CryptoExchange.Net.UnitTests
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             var ct = new CancellationTokenSource(TimeSpan.FromSeconds(0.2));
 
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("https://test.com", "1", HttpMethod.Get), "123", 1, RateLimitingBehaviour.Wait, null, 1, ct.Token);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("https://test.com", "1", HttpMethod.Get), "123", 1, RateLimitingBehaviour.Wait, null, 1, ct.Token);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("https://test.com", "1", HttpMethod.Get), "123", 1, RateLimitingBehaviour.Wait, null, ct.Token);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("https://test.com", "1", HttpMethod.Get), "123", 1, RateLimitingBehaviour.Wait, null, ct.Token);
             Assert.That(result2.Error, Is.TypeOf<CancellationRequestedError>());
         }
 
@@ -258,9 +257,9 @@ namespace CryptoExchange.Net.UnitTests
             var ct = new CancellationTokenSource(TimeSpan.FromSeconds(0.2));
 
             // act
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition, null, 1, RateLimitingBehaviour.Fail, null, 1, ct.Token);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition, null, 1, RateLimitingBehaviour.Fail, null, ct.Token);
             await rateLimiter.ResetAsync(RateLimitItemType.Request, definition, null, null, null, default);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition, null, 1, RateLimitingBehaviour.Fail, null, 1, ct.Token);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition, null, 1, RateLimitingBehaviour.Fail, null, ct.Token);
             
             // assert
             Assert.That(evnt, Is.Null);
@@ -280,10 +279,10 @@ namespace CryptoExchange.Net.UnitTests
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
             // act
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition1, null, 1, RateLimitingBehaviour.Fail, null, 1, default);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition2, null, 1, RateLimitingBehaviour.Fail, null, 1, default);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition1, null, 1, RateLimitingBehaviour.Fail, null, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition2, null, 1, RateLimitingBehaviour.Fail, null, default);
             await rateLimiter.ResetAsync(RateLimitItemType.Request, definition1, null, null, null, default);
-            var result3 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition2, null, 1, RateLimitingBehaviour.Fail, null, 1, default);
+            var result3 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, definition2, null, 1, RateLimitingBehaviour.Fail, null, default);
             
             // assert
             Assert.That(evnt, Is.Not.Null);
@@ -322,73 +321,5 @@ namespace CryptoExchange.Net.UnitTests
             // assert
             Assert.That(evnt != null, Is.EqualTo(expectLimited));
         }
-
-        [TestCase(RateLimitWindowType.Fixed)]
-        [TestCase(RateLimitWindowType.FixedAfterFirst)]
-        [TestCase(RateLimitWindowType.Sliding)]
-        [TestCase(RateLimitWindowType.Decay)]
-        public async Task LowerThreshold_ReservesCapacityForFullThreshold(RateLimitWindowType windowType)
-        {
-            var gate = new RateLimitGate("Test");
-            gate.AddGuard(new RateLimitGuard(
-                RateLimitGuard.PerHost,
-                new LimitItemTypeFilter(RateLimitItemType.Request),
-                10,
-                TimeSpan.FromHours(1),
-                windowType,
-                decayPerTimeSpan: 1));
-
-            var definition = new RequestDefinition(
-                "https://test.com", "/ticker", HttpMethod.Get);
-            var logger = new TraceLogger();
-
-            for (var i = 0; i < 8; i++)
-            {
-                var result = await gate.ProcessAsync(
-                    logger, i, RateLimitItemType.Request, definition, null, 1,
-                    RateLimitingBehaviour.Fail, null, 0.8, default);
-                Assert.That(result.Success, Is.True);
-            }
-
-            var marketData = await gate.ProcessAsync(
-                logger, 9, RateLimitItemType.Request, definition, null, 1,
-                RateLimitingBehaviour.Fail, null, 0.8, default);
-            Assert.That(marketData.Error, Is.TypeOf<ClientRateLimitError>());
-
-            var order = await gate.ProcessAsync(
-                logger, 10, RateLimitItemType.Request, definition, null, 2,
-                RateLimitingBehaviour.Fail, null, 1.0, default);
-            Assert.That(order.Success, Is.True);
-
-            var overHardLimit = await gate.ProcessAsync(
-                logger, 11, RateLimitItemType.Request, definition, null, 1,
-                RateLimitingBehaviour.Fail, null, 1.0, default);
-            Assert.That(overHardLimit.Error, Is.TypeOf<ClientRateLimitError>());
-        }
-
-        [TestCase(0.1, 10)]
-        [TestCase(1, 50)]
-        [TestCase(5, 250)]
-        [TestCase(60, 250)]
-        public void RateLimitSafetyMargin_DefaultIsProportionalAndCapped(double periodSeconds, int expectedMarginMilliseconds)
-        {
-            var margin = WindowTrackerHelpers.GetDefaultSafetyMargin(TimeSpan.FromSeconds(periodSeconds));
-
-            Assert.That(margin, Is.EqualTo(TimeSpan.FromMilliseconds(expectedMarginMilliseconds)));
-        }
-
-        [Test]
-        public void RateLimitGuard_ExplicitSafetyMarginIsUsed()
-        {
-            var guard = new RateLimitGuard(
-                RateLimitGuard.PerHost,
-                new LimitItemTypeFilter(RateLimitItemType.Request),
-                1,
-                TimeSpan.FromSeconds(1),
-                RateLimitWindowType.Sliding,
-                safetyMargin: TimeSpan.Zero);
-
-            Assert.That(guard.SafetyMargin, Is.EqualTo(TimeSpan.Zero));
-        }
     }
 }

CryptoExchange.Net.UnitTests/SharedApiClientTests.cs

@@ -1,355 +0,0 @@
-using CryptoExchange.Net.Interfaces.Clients;
-using CryptoExchange.Net.RateLimiting;
-using CryptoExchange.Net.SharedApis;
-using Microsoft.Extensions.DependencyInjection;
-using NUnit.Framework;
-using System;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.UnitTests
-{
-    [TestFixture]
-    internal class SharedApiClientTests
-    {
-        [Test]
-        public void GetCapability_ShouldUseCapabilityTradingModes()
-        {
-            var sharedApi = new TestSharedApi(
-                [TradingMode.Spot, TradingMode.PerpetualLinear],
-                [TradingMode.Spot]);
-            var client = new TestSharedApiClient(sharedApi);
-
-            Assert.Multiple(() =>
-            {
-                Assert.That(client.GetCapability<ITestCapability>(TradingMode.Spot)?.Capability, Is.SameAs(sharedApi));
-                Assert.That(client.GetCapability<ITestCapability>(TradingMode.PerpetualLinear), Is.Null);
-                Assert.That(client.GetCapabilities<ITestCapability>(TradingMode.Spot), Has.Count.EqualTo(1));
-                Assert.That(client.GetCapabilities<ITestCapability>(TradingMode.PerpetualLinear), Is.Empty);
-            });
-        }
-
-        [Test]
-        public void CapabilityTradingModes_ShouldDefaultToSharedApiTradingModes()
-        {
-            var sharedApi = new TestSharedApi(
-                [TradingMode.Spot, TradingMode.PerpetualLinear],
-                null);
-            var client = new TestSharedApiClient(sharedApi);
-
-            Assert.Multiple(() =>
-            {
-                Assert.That(client.GetCapability<ITestCapability>(TradingMode.Spot)?.Capability, Is.SameAs(sharedApi));
-                Assert.That(client.GetCapability<ITestCapability>(TradingMode.PerpetualLinear)?.Capability, Is.SameAs(sharedApi));
-            });
-        }
-
-        [Test]
-        public void GetCapabilities_WithReference_ShouldReturnMatchingCapabilities()
-        {
-            var sharedApi = new TestSharedApi(
-                [TradingMode.Spot],
-                [TradingMode.Spot]);
-            var client = new TestSharedApiClient(sharedApi);
-
-            var result = client.GetCapabilities(
-                new SharedCapabilityReference<ITestCapability>(),
-                TradingMode.Spot);
-
-            Assert.That(result, Has.Count.EqualTo(1));
-            Assert.That(result[0].Capability, Is.SameAs(sharedApi));
-            Assert.That(result[0].Options, Is.SameAs(sharedApi.CapabilityOptions));
-        }
-
-        [Test]
-        public void Discover_ShouldReturnAllSharedApiInformation()
-        {
-            var restApi = new TestRestSharedApi();
-            var socketApi = new TestSocketSharedApi();
-            var client = new TestDiSharedApiClient(
-                restApi,
-                socketApi);
-
-            var result = client.Discover();
-
-            Assert.Multiple(() =>
-            {
-                Assert.That(result.PreferredTransport, Is.EqualTo(SharedTransport.Socket));
-                Assert.That(result.SharedApis, Has.Length.EqualTo(2));
-                Assert.That(result.SharedApis[0].Transport, Is.EqualTo(SharedTransport.Rest));
-                Assert.That(result.SharedApis[1].Transport, Is.EqualTo(SharedTransport.Socket));
-                Assert.That(result.SharedApis[0].SupportedTradingModes, Is.EqualTo(new[] { TradingMode.Spot }));
-                Assert.That(result.SharedApis[0].Capabilities, Has.Length.EqualTo(1));
-                Assert.That(result.SharedApis[0].Authenticated, Is.False);
-            });
-        }
-
-        [Test]
-        public void RegisterSharedApiClient_ShouldResolvePreferredTransport()
-        {
-            var restApi = new TestRestSharedApi();
-            var socketApi = new TestSocketSharedApi();
-            var services = new ServiceCollection();
-
-            services.AddSingleton(restApi);
-            services.AddSingleton(socketApi);
-
-            services.RegisterSharedApiClient<
-                ITestSharedApiClient,
-                TestDiSharedApiClient>(sharedApis => sharedApis
-                    .Add(client => client.Rest)
-                    .Add(client => client.Socket));
-
-            using var provider = services.BuildServiceProvider();
-
-            Assert.Multiple(() =>
-            {
-                Assert.That(
-                    provider.GetRequiredService<ITestSharedApiClient>(),
-                    Is.Not.Null);
-
-                Assert.That(
-                    provider.GetRequiredService<ISharedApiClientBase>(),
-                    Is.InstanceOf<TestDiSharedApiClient>());
-
-                Assert.That(
-                    provider.GetRequiredService<ITestCapability>(),
-                    Is.SameAs(socketApi));
-
-                Assert.That(
-                    provider.GetServices<ITestCapability>().ToArray(),
-                    Is.EqualTo(new[] { socketApi }));
-
-                Assert.That(
-                    provider.GetRequiredService<ITestRestCapability>(),
-                    Is.SameAs(restApi));
-
-                Assert.That(
-                    provider.GetRequiredService<ITestSocketCapability>(),
-                    Is.SameAs(socketApi));
-            });
-        }
-
-        [Test]
-        public void CapabilityTradingModes_ShouldIntersectApiApplicableAndOverrideModes()
-        {
-            var sharedApi = new TestSharedApi(
-                [TradingMode.Spot, TradingMode.PerpetualLinear, TradingMode.DeliveryLinear],
-                [TradingMode.Spot, TradingMode.PerpetualLinear],
-                [TradingMode.PerpetualLinear, TradingMode.DeliveryLinear]);
-
-            Assert.That(
-                sharedApi.CapabilityOptions.SupportedTradingModes,
-                Is.EqualTo(new[] { TradingMode.PerpetualLinear }));
-        }
-
-        [Test]
-        public void CapabilityOptions_ShouldApplyIntrinsicTradingModes()
-        {
-            var apiModes = new[]
-            {
-                TradingMode.Spot,
-                TradingMode.PerpetualLinear,
-                TradingMode.DeliveryLinear,
-                TradingMode.PerpetualInverse,
-                TradingMode.DeliveryInverse
-            };
-            var spotOptions = new PlaceSpotOrderOptions("TestExchange");
-            var futuresOptions = new GetPositionsOptions("TestExchange", false);
-            var perpetualOptions = new GetFundingRateHistoryOptions(
-                "TestExchange",
-                true,
-                true,
-                true,
-                100,
-                false);
-            var unrestrictedOptions = new GetTickerOptions("TestExchange");
-
-            _ = new TestOptionsHost(apiModes, spotOptions);
-            _ = new TestOptionsHost(apiModes, futuresOptions);
-            _ = new TestOptionsHost(apiModes, perpetualOptions);
-            _ = new TestOptionsHost(apiModes, unrestrictedOptions);
-
-            Assert.Multiple(() =>
-            {
-                Assert.That(spotOptions.SupportedTradingModes, Is.EqualTo(new[] { TradingMode.Spot }));
-                Assert.That(futuresOptions.SupportedTradingModes, Is.EqualTo(new[]
-                {
-                    TradingMode.PerpetualLinear,
-                    TradingMode.DeliveryLinear,
-                    TradingMode.PerpetualInverse,
-                    TradingMode.DeliveryInverse
-                }));
-                Assert.That(perpetualOptions.SupportedTradingModes, Is.EqualTo(new[]
-                {
-                    TradingMode.PerpetualLinear,
-                    TradingMode.PerpetualInverse
-                }));
-                Assert.That(unrestrictedOptions.SupportedTradingModes, Is.EqualTo(apiModes));
-            });
-        }
-
-        private interface ITestCapability : ISharedApiCapability
-        {
-        }
-
-        private sealed class TestApiClient : IBaseApiClient
-        {
-            public string Exchange => "TestExchange";
-            public string BaseAddress => "https://test.invalid";
-
-            public string FormatSymbol(
-                string baseAsset,
-                string quoteAsset,
-                TradingMode tradingMode,
-                DateTime? deliverDate = null)
-                => $"{baseAsset}{quoteAsset}";
-
-            public Task<TResult> WithRateLimitAdmissionAsync<TResult>(
-                RateLimitAdmission admission,
-                Func<Task<TResult>> operation)
-                => operation();
-        }
-
-        private interface ITestRestCapability : ITestCapability, ISharedRest
-        {
-        }
-
-        private interface ITestSocketCapability : ITestCapability, ISharedSocket
-        {
-        }
-
-        private interface ITestRestSharedApi : ITestRestCapability
-        {
-        }
-
-        private interface ITestSocketSharedApi : ITestSocketCapability
-        {
-        }
-
-        private interface ITestSharedApiClient : ISharedApiClientBase
-        {
-            ITestRestSharedApi Rest { get; }
-            ITestSocketSharedApi Socket { get; }
-        }
-
-        private sealed class TestCapabilityOptions : CapabilityOptions<SharedRequest, ITestCapability>
-        {
-            public override string Description => "Test capability";
-
-            public TestCapabilityOptions(TradingMode[]? applicableTradingModes)
-                : base("TestExchange", false, "TestOperation", [], applicableTradingModes)
-            {
-            }
-        }
-
-        private sealed class TestSharedApi : SharedApiBase, ITestCapability
-        {
-            public TestCapabilityOptions CapabilityOptions { get; }
-
-            public TestSharedApi(TradingMode[] apiTradingModes, TradingMode[]? capabilityTradingModes)
-                : this(apiTradingModes, capabilityTradingModes, null)
-            {
-            }
-
-            public TestSharedApi(
-                TradingMode[] apiTradingModes,
-                TradingMode[]? capabilityTradingModes,
-                TradingMode[]? applicableTradingModes)
-                : base(
-                    SharedTransport.Rest,
-                    new TestApiClient(),
-                    apiTradingModes,
-                    () => false,
-                    (baseAsset, quoteAsset, tradingMode, deliverDate) => $"{baseAsset}{quoteAsset}")
-            {
-                var options = new TestCapabilityOptions(applicableTradingModes)
-                {
-                    SupportedTradingModeOverrides = capabilityTradingModes
-                };
-
-                SetCapabilities(options);
-                CapabilityOptions = options;
-            }
-
-            public override SharedClientInfo Discover() => new();
-        }
-
-        private sealed class TestOptionsHost : SharedApiBase
-        {
-            public TestOptionsHost(TradingMode[] apiTradingModes, CapabilityOptions capabilityOptions)
-                : base(
-                    SharedTransport.Rest,
-                    new TestApiClient(),
-                    apiTradingModes,
-                    () => false,
-                    (baseAsset, quoteAsset, tradingMode, deliverDate) => $"{baseAsset}{quoteAsset}")
-            {
-                SetCapabilities(capabilityOptions);
-            }
-
-            public override SharedClientInfo Discover() => new();
-        }
-
-        private abstract class TestTransportSharedApi : SharedApiBase
-        {
-            protected TestTransportSharedApi(SharedTransport transport)
-                : base(
-                    transport,
-                    new TestApiClient(),
-                    [TradingMode.Spot],
-                    () => false,
-                    (baseAsset, quoteAsset, tradingMode, deliverDate) => $"{baseAsset}{quoteAsset}")
-            {
-                SetCapabilities(new TestCapabilityOptions([TradingMode.Spot]));
-            }
-
-            public override SharedClientInfo Discover() => new()
-            {
-                Exchange = this.Exchange,
-                TypeName = GetType().Name,
-                SupportedTradingModes = this.SupportedTradingModes,
-                Transport = this.Transport,
-                Authenticated = this.Authenticated,
-                Capabilities = ((ISharedApi)this).Capabilities.ToArray()
-            };
-        }
-
-        private sealed class TestRestSharedApi : TestTransportSharedApi, ITestRestSharedApi
-        {
-            public TestRestSharedApi() : base(SharedTransport.Rest)
-            {
-            }
-        }
-
-        private sealed class TestSocketSharedApi : TestTransportSharedApi, ITestSocketSharedApi
-        {
-            public TestSocketSharedApi() : base(SharedTransport.Socket)
-            {
-            }
-        }
-
-        private sealed class TestDiSharedApiClient : SharedApiClientBase, ITestSharedApiClient
-        {
-            public ITestRestSharedApi Rest { get; }
-            public ITestSocketSharedApi Socket { get; }
-
-            public TestDiSharedApiClient(
-                TestRestSharedApi rest,
-                TestSocketSharedApi socket)
-                : base(SharedTransport.Socket, rest, socket)
-            {
-                Rest = rest;
-                Socket = socket;
-            }
-        }
-
-        private sealed class TestSharedApiClient : SharedApiClientBase
-        {
-            public TestSharedApiClient(params ISharedApiCapability[] sharedApis)
-                : base(SharedTransport.Rest, sharedApis)
-            {
-            }
-        }
-    }
-}

CryptoExchange.Net.UnitTests/SharedCapabilitiesTests.cs

@@ -1,89 +0,0 @@
-using CryptoExchange.Net.SharedApis;
-using NUnit.Framework;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-
-namespace CryptoExchange.Net.UnitTests
-{
-    [TestFixture]
-    internal class SharedCapabilitiesTests
-    {
-        [Test]
-        public void AllSharedApiCapabilities_ShouldBeListedInSharedCapabilities()
-        {
-            var markerTypes = new[]
-            {
-                typeof(ISharedApiCapability),
-                typeof(ISharedRest),
-                typeof(ISharedSocket),
-                typeof(ISharedSubscription)
-            };
-
-            var expectedCapabilities = typeof(ISharedApiCapability).Assembly
-                .GetTypes()
-                .Where(x => x.IsInterface
-                            && typeof(ISharedApiCapability).IsAssignableFrom(x)
-                            && !markerTypes.Contains(x))
-                .OrderBy(x => x.FullName)
-                .ToArray();
-
-            var listedCapabilities = GetTypeAndNestedTypes(typeof(SharedCapabilities))
-                .SelectMany(x => x.GetProperties(
-                    BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly))
-                .SelectMany(x => x.PropertyType.GetGenericArguments())
-                .Where(x => x.IsInterface
-                            && typeof(ISharedApiCapability).IsAssignableFrom(x))
-                .ToArray();
-
-            var missingCapabilities = expectedCapabilities
-                .Except(listedCapabilities)
-                .Select(x => x.Name)
-                .ToArray();
-
-            var unknownCapabilities = listedCapabilities
-                .Except(expectedCapabilities)
-                .Select(x => x.Name)
-                .ToArray();
-
-            var duplicateCapabilities = listedCapabilities
-                .GroupBy(x => x)
-                .Where(x => x.Count() > 1)
-                .Select(x => x.Key.Name)
-                .ToArray();
-
-            Assert.Multiple(() =>
-            {
-                Assert.That(
-                    missingCapabilities,
-                    Is.Empty,
-                    $"Capabilities missing from SharedCapabilities: " +
-                    string.Join(", ", missingCapabilities));
-
-                Assert.That(
-                    unknownCapabilities,
-                    Is.Empty,
-                    $"Unknown capabilities listed in SharedCapabilities: " +
-                    string.Join(", ", unknownCapabilities));
-
-                Assert.That(
-                    duplicateCapabilities,
-                    Is.Empty,
-                    $"Capabilities listed multiple times in SharedCapabilities: " +
-                    string.Join(", ", duplicateCapabilities));
-            });
-        }
-
-        private static IEnumerable<Type> GetTypeAndNestedTypes(Type type)
-        {
-            yield return type;
-
-            foreach (var nestedType in type.GetNestedTypes(BindingFlags.Public))
-            {
-                foreach (var result in GetTypeAndNestedTypes(nestedType))
-                    yield return result;
-            }
-        }
-    }
-}

CryptoExchange.Net.UnitTests/SharedParametersTests.cs

@@ -1,180 +0,0 @@
-using NUnit.Framework;
-using CryptoExchange.Net.SharedApis;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-
-namespace CryptoExchange.Net.UnitTests
-{
-    [TestFixture]
-    internal class SharedParametersTests
-    {
-        [Test]
-        public void AllSharedAPIOptions_ShouldListAllDefaultParametersInRequestParameterRules()
-        {
-            var failures = new List<string>();
-
-            var optionsTypes = typeof(CapabilityOptions).Assembly
-                .GetTypes()
-                .Where(x => x.IsClass
-                            && !x.IsAbstract
-                            && typeof(CapabilityOptions).IsAssignableFrom(x))
-                .OrderBy(x => x.FullName)
-                .ToArray();
-
-            foreach (var optionsType in optionsTypes)
-            {
-                var genericOptionsType = GetGenericOptionsType(optionsType);
-                if (genericOptionsType == null)
-                {
-                    if (optionsType == typeof(ClosePositionOptions))
-                        continue;
-
-                    failures.Add($"{optionsType.Name}: unable to determine request type");
-                    continue;
-                }
-
-                var requestType = genericOptionsType.GetGenericArguments()[0];
-                var defaultRulesField = GetDefaultParameterRulesField(optionsType);
-                if (defaultRulesField == null)
-                {
-                    failures.Add($"{optionsType.Name}: no _defaultParameterRules field found");
-                    continue;
-                }
-
-                var rules = (RequestParameterDescription[]?)defaultRulesField.GetValue(null);
-                if (rules == null)
-                {
-                    failures.Add($"{optionsType.Name}: _defaultParameterRules is null");
-                    continue;
-                }
-
-                var constructorParameterNames = requestType
-                    .GetConstructors(BindingFlags.Instance | BindingFlags.Public)
-                    .SelectMany(x => x.GetParameters())
-                    .Where(x => !string.Equals(
-                        x.Name,
-                        "exchangeParameters",
-                        StringComparison.OrdinalIgnoreCase))
-                    .Select(x => x.Name!)
-                    .ToHashSet(StringComparer.OrdinalIgnoreCase);
-
-                var parameterProperties = requestType
-                    .GetProperties(BindingFlags.Instance | BindingFlags.Public)
-                    .Where(x => x.DeclaringType == requestType
-                                || constructorParameterNames.Contains(x.Name))
-                    .Where(x => x.Name != nameof(SharedRequest.ExchangeParameters))
-                    .Select(x => x.Name)
-                    .OrderBy(x => x)
-                    .ToArray();
-
-                var ruleNames = rules
-                    .Select(x => x.Name)
-                    .ToHashSet(StringComparer.Ordinal);
-
-                foreach (var parameterProperty in parameterProperties)
-                {
-                    if (!ruleNames.Contains(parameterProperty))
-                    {
-                        failures.Add(
-                            $"{optionsType.Name}: request property " +
-                            $"{requestType.Name}.{parameterProperty} has no default request parameter rule");
-                    }
-                }
-            }
-
-            Assert.That(
-                failures,
-                Is.Empty,
-                $"Missing default request parameter rules:{Environment.NewLine}" +
-                string.Join(Environment.NewLine, failures));
-        }
-
-        [Test]
-        public void RequiredExchangeParameter_ShouldAcceptNameOrAnyAlias()
-        {
-            const string exchange = "TestExchange";
-            var options = new GetTickerOptions(exchange)
-            {
-                ExchangeParameterRules =
-                [
-                    ExchangeParameterRule.Required(
-                        "Parameter",
-                        "Test parameter",
-                        1,
-                        "Alias1",
-                        "Alias2")
-                ]
-            };
-
-            var missingResult = options.ValidateRequest(null, null, [TradingMode.Spot]);
-            var nameResult = options.ValidateRequest(
-                new ExchangeParameters(new ExchangeParameter(exchange, "Parameter", 1)),
-                null,
-                [TradingMode.Spot]);
-            var firstAliasResult = options.ValidateRequest(
-                new ExchangeParameters(new ExchangeParameter(exchange, "Alias1", 1)),
-                null,
-                [TradingMode.Spot]);
-            var secondAliasResult = options.ValidateRequest(
-                new ExchangeParameters(new ExchangeParameter(exchange, "Alias2", 1)),
-                null,
-                [TradingMode.Spot]);
-
-            Assert.Multiple(() =>
-            {
-                Assert.That(missingResult, Is.Not.Null);
-                Assert.That(nameResult, Is.Null);
-                Assert.That(firstAliasResult, Is.Null);
-                Assert.That(secondAliasResult, Is.Null);
-            });
-        }
-
-        [Test]
-        public void RequiredExchangeParameterWithoutAliases_ShouldBeRequired()
-        {
-            const string exchange = "TestExchange";
-            var options = new GetTickerOptions(exchange)
-            {
-                ExchangeParameterRules =
-                [
-                    ExchangeParameterRule.Required(
-                        "Parameter",
-                        "Test parameter",
-                        1)
-                ]
-            };
-
-            var result = options.ValidateRequest(null, null, [TradingMode.Spot]);
-
-            Assert.That(result, Is.Not.Null);
-        }
-
-        private static Type? GetGenericOptionsType(Type optionsType)
-        {
-            for (var type = optionsType; type != null; type = type.BaseType)
-            {
-                if (type.IsGenericType
-                    && type.GetGenericTypeDefinition() == typeof(CapabilityOptions<,>))
-                    return type;
-            }
-
-            return null;
-        }
-
-        private static FieldInfo? GetDefaultParameterRulesField(Type optionsType)
-        {
-            for (var type = optionsType; type != null; type = type.BaseType)
-            {
-                var field = type.GetField(
-                    "_defaultParameterRules",
-                    BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
-                if (field != null)
-                    return field;
-            }
-
-            return null;
-        }
-    }
-}

CryptoExchange.Net/Clients/BaseApiClient.cs

@@ -1,13 +1,10 @@
+using System;
 using CryptoExchange.Net.Interfaces.Clients;
 using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Options;
-using CryptoExchange.Net.RateLimiting;
 using CryptoExchange.Net.SharedApis;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
-using System;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace CryptoExchange.Net.Clients
 {
@@ -81,11 +78,6 @@ namespace CryptoExchange.Net.Clients
         /// </summary>
         protected internal virtual ErrorMapping ErrorMapping { get; } = new ErrorMapping([]);
 
-        /// <summary>
-        /// Current rate limit admission override
-        /// </summary>
-        protected readonly AsyncLocal<RateLimitAdmission?> AdmissionOverride = new();
-
         /// <summary>
         /// ctor
         /// </summary>
@@ -130,29 +122,6 @@ namespace CryptoExchange.Net.Clients
         /// </summary>
         public ErrorInfo GetErrorInfo(string code, string? message = null) => ErrorMapping.GetErrorInfo(code.ToString(), message);
 
-        /// <inheritdoc />
-        public async Task<TResult> WithRateLimitAdmissionAsync<TResult>(
-            RateLimitAdmission admission,
-            Func<Task<TResult>> operation)
-        {
-            if (admission == null)
-                throw new ArgumentNullException(nameof(admission));
-            if (operation == null)
-                throw new ArgumentNullException(nameof(operation));
-
-            var previous = AdmissionOverride.Value;
-            AdmissionOverride.Value = admission;
-
-            try
-            {
-                return await operation().ConfigureAwait(false);
-            }
-            finally
-            {
-                AdmissionOverride.Value = previous;
-            }
-        }
-
         /// <summary>
         /// Dispose
         /// </summary>

CryptoExchange.Net/Clients/RestApiClient.cs

@@ -350,9 +350,6 @@ namespace CryptoExchange.Net.Clients
 
                 if (ClientOptions.RateLimiterEnabled)
                 {
-                    var admissionOverride = AdmissionOverride.Value ?? ClientOptions.RateLimitAdmission?.Invoke(definition, requestWeight);
-                    var rateRatio = admissionOverride?.MaxUtilizationRatio ?? 1.0;                  
-
                     var limitResult = await definition.RateLimitGate.ProcessAsync(
                         _logger,
                         requestId,
@@ -362,7 +359,6 @@ namespace CryptoExchange.Net.Clients
                         requestWeight,
                         ClientOptions.RateLimitingBehaviour,
                         rateLimitKeySuffix + ClientOptions.RateLimitGroup,
-                        rateRatio,
                         cancellationToken).ConfigureAwait(false);
                     if (!limitResult.Success)
                         return limitResult.Error!;
@@ -378,9 +374,6 @@ namespace CryptoExchange.Net.Clients
                 if (ClientOptions.RateLimiterEnabled)
                 {
                     var singleRequestWeight = weightSingleLimiter ?? 1;
-                    var admissionOverride = AdmissionOverride.Value ?? ClientOptions.RateLimitAdmission?.Invoke(definition, singleRequestWeight);
-                    var rateRatio = admissionOverride?.MaxUtilizationRatio ?? 1.0;
-
                     var limitResult = await definition.RateLimitGate.ProcessSingleAsync(
                         _logger,
                         requestId,
@@ -391,7 +384,6 @@ namespace CryptoExchange.Net.Clients
                         singleRequestWeight,
                         ClientOptions.RateLimitingBehaviour,
                         rateLimitKeySuffix,
-                        rateRatio,
                         cancellationToken).ConfigureAwait(false);
                     if (!limitResult.Success)
                         return limitResult.Error!;

CryptoExchange.Net/Clients/SocketApiClient.cs

@@ -286,7 +286,7 @@ namespace CryptoExchange.Net.Clients
                     while (true)
                     {
                         // Get a new or existing socket connection
-                        var socketResult = await GetSocketConnection(url, subscription.Authenticated, false, ct, subscription, subscription.Topic, subscription.IndividualSubscriptionCount).ConfigureAwait(false);
+                        var socketResult = await GetSocketConnection(url, subscription.Authenticated, false, ct, subscription.Topic, subscription.IndividualSubscriptionCount).ConfigureAwait(false);
                         if (!socketResult.Success)
                             return WebSocketResult.Fail<UpdateSubscription>(Exchange, socketResult.Error);
 
@@ -309,7 +309,7 @@ namespace CryptoExchange.Net.Clients
 
                         var needsConnecting = !socketConnection.Connected;
 
-                        var connectResult = await ConnectIfNeededAsync(socketConnection, subscription.Authenticated, ct, subscription).ConfigureAwait(false);
+                        var connectResult = await ConnectIfNeededAsync(socketConnection, subscription.Authenticated, ct).ConfigureAwait(false);
                         if (!connectResult.Success)
                             return WebSocketResult.Fail<UpdateSubscription>(Exchange, connectResult.Error!);
 
@@ -482,7 +482,7 @@ namespace CryptoExchange.Net.Clients
             await semaphoreSlim.WaitAsync().ConfigureAwait(false);
             try
             {
-                var socketResult = await GetSocketConnection(url, query.Authenticated, true, ct, processor: query).ConfigureAwait(false);
+                var socketResult = await GetSocketConnection(url, query.Authenticated, true, ct).ConfigureAwait(false);
                 if (!socketResult.Success)
                     return QueryResult.Fail<THandlerResponse>(Exchange, socketResult.Error);
 
@@ -495,7 +495,7 @@ namespace CryptoExchange.Net.Clients
                     released = true;
                 }
 
-                var connectResult = await ConnectIfNeededAsync(socketConnection, query.Authenticated, ct, query).ConfigureAwait(false);
+                var connectResult = await ConnectIfNeededAsync(socketConnection, query.Authenticated, ct).ConfigureAwait(false);
                 if (!connectResult.Success)
                     return QueryResult.Fail<THandlerResponse>(Exchange, connectResult.Error!);
             }
@@ -524,18 +524,7 @@ namespace CryptoExchange.Net.Clients
         /// <param name="authenticated">Whether the socket should authenticated</param>
         /// <param name="ct">Cancellation token</param>
         /// <returns></returns>
-        protected virtual Task<CallResult> ConnectIfNeededAsync(ISocketConnection socket, bool authenticated, CancellationToken ct)
-            => ConnectIfNeededAsync(socket, authenticated, ct, null);
-
-        /// <summary>
-        /// Checks if a socket needs to be connected and does so if needed. Also authenticates on the socket if needed
-        /// </summary>
-        /// <param name="socket">The connection to check</param>
-        /// <param name="authenticated">Whether the socket should authenticated</param>
-        /// <param name="processor">The message processor requesting a connection</param>
-        /// <param name="ct">Cancellation token</param>
-        /// <returns></returns>
-        protected virtual async Task<CallResult> ConnectIfNeededAsync(ISocketConnection socket, bool authenticated, CancellationToken ct, IMessageProcessor? processor)
+        protected virtual async Task<CallResult> ConnectIfNeededAsync(ISocketConnection socket, bool authenticated, CancellationToken ct)
         {
             if (socket.Connected)
                 return CallResult.Ok();
@@ -544,13 +533,16 @@ namespace CryptoExchange.Net.Clients
             if (!connectResult.Success)
                 return connectResult;
 
+            if (ClientOptions.DelayAfterConnect != TimeSpan.Zero)
+                await Task.Delay(ClientOptions.DelayAfterConnect).ConfigureAwait(false);
+
             if (!authenticated || socket.Authenticated)
                 return CallResult.Ok();
 
             if (socket is not SocketConnection sc)
                 throw new InvalidOperationException("HighPerfSocketConnection not supported for authentication");
 
-            var result = await AuthenticateSocketAsync(sc, processor).ConfigureAwait(false);
+            var result = await AuthenticateSocketAsync(sc).ConfigureAwait(false);
             if (!result.Success)
                 await socket.CloseAsync().ConfigureAwait(false);
 
@@ -562,22 +554,13 @@ namespace CryptoExchange.Net.Clients
         /// </summary>
         /// <param name="socket">Socket to authenticate</param>
         /// <returns></returns>
-        public virtual Task<CallResult> AuthenticateSocketAsync(SocketConnection socket)
-            => AuthenticateSocketAsync(socket, null);
-
-        /// <summary>
-        /// Authenticate a socket connection
-        /// </summary>
-        /// <param name="socket">Socket to authenticate</param>
-        /// <param name="processor">The message processor requesting authentication</param>
-        /// <returns></returns>
-        public virtual async Task<CallResult> AuthenticateSocketAsync(SocketConnection socket, IMessageProcessor? processor)
+        public virtual async Task<CallResult> AuthenticateSocketAsync(SocketConnection socket)
         {
             if (GetAuthenticationProvider() == null)
                 return CallResult.Fail(new NoApiCredentialsError());
 
             _logger.AttemptingToAuthenticate(socket.SocketId);
-            var authRequest = await GetAuthenticationRequestAsync(socket, processor).ConfigureAwait(false);
+            var authRequest = await GetAuthenticationRequestAsync(socket).ConfigureAwait(false);
             if (authRequest != null)
             {
                 var result = await socket.SendAndWaitQueryAsync(authRequest).ConfigureAwait(false);
@@ -598,21 +581,13 @@ namespace CryptoExchange.Net.Clients
             return CallResult.Ok();
         }
 
-
         /// <summary>
         /// Should return the request which can be used to authenticate a socket connection
         /// </summary>
         /// <returns></returns>
-        protected internal virtual Task<Query?> GetAuthenticationRequestAsync(SocketConnection connection) =>
+        protected internal virtual Task<Query?> GetAuthenticationRequestAsync(SocketConnection connection) => 
             Task.FromResult(GetAuthenticationProvider()!.GetAuthenticationQuery(this, connection));
 
-        /// <summary>
-        /// Should return the request which can be used to authenticate a socket connection
-        /// </summary>
-        /// <returns></returns>
-        protected internal virtual Task<Query?> GetAuthenticationRequestAsync(SocketConnection connection, IMessageProcessor? processor) =>
-            GetAuthenticationRequestAsync(connection);
-
         /// <summary>
         /// Adds a system subscription. Used for example to reply to ping requests
         /// </summary>
@@ -670,18 +645,6 @@ namespace CryptoExchange.Net.Clients
                 && (AllowTopicsOnTheSameConnection || !connection.Topics.Contains(topic));
         }
 
-        /// <summary>
-        /// Whether the connection can be used for a new subscription or query with the provided parameters
-        /// </summary>
-        /// <param name="connection">The connection to check</param>
-        /// <param name="address">The address set by the request</param>
-        /// <param name="authenticated">Whether the request needs an authenticated connection</param>
-        /// <param name="processor">The processor requesting a connection</param>
-        /// <param name="topic">Topic of the request</param>
-        /// <returns>True if connection can be used</returns>
-        protected virtual bool ConnectionCanBeUsedFor(SocketConnection connection, string address, bool authenticated, IMessageProcessor? processor, string? topic = null)
-            => ConnectionCanBeUsedFor(connection, address, authenticated, topic);
-
         /// <summary>
         /// Gets a connection for a new subscription or query. Can be an existing if there are open position or a new one.
         /// </summary>
@@ -692,36 +655,15 @@ namespace CryptoExchange.Net.Clients
         /// <param name="topic">The subscription topic, can be provided when multiple of the same topics are not allowed on a connection</param>
         /// <param name="individualSubscriptionCount">The number of individual subscriptions in this subscribe request</param>
         /// <returns></returns>
-        protected virtual Task<CallResult<SocketConnection>> GetSocketConnection(
-            string address,
-            bool authenticated,
-            bool dedicatedRequestConnection,
-            CancellationToken ct,
-            string? topic = null,
-            int individualSubscriptionCount = 1)
-            => GetSocketConnection(address, authenticated, dedicatedRequestConnection, ct, null, topic, individualSubscriptionCount);
-
-        /// <summary>
-        /// Gets a connection for a new subscription or query. Can be an existing if there are open position or a new one.
-        /// </summary>
-        /// <param name="address">The address the socket is for</param>
-        /// <param name="authenticated">Whether the socket should be authenticated</param>
-        /// <param name="dedicatedRequestConnection">Whether a dedicated request connection should be returned</param>
-        /// <param name="ct">Cancellation token</param>
-        /// <param name="topic">The subscription topic, can be provided when multiple of the same topics are not allowed on a connection</param>
-        /// <param name="individualSubscriptionCount">The number of individual subscriptions in this subscribe request</param>
-        /// <param name="processor">The processor requesting a connection</param>
-        /// <returns></returns>
         protected virtual async Task<CallResult<SocketConnection>> GetSocketConnection(
             string address,
             bool authenticated,
             bool dedicatedRequestConnection, 
             CancellationToken ct,
-            IMessageProcessor? processor,
             string? topic = null,
             int individualSubscriptionCount = 1)
         {
-            var socketQuery = _socketConnections.Where(s => ConnectionCanBeUsedFor(s.Value, address, authenticated, processor, topic)).Select(x => x.Value); // Don't ToList this so the query is executed again when called
+            var socketQuery = _socketConnections.Where(s => ConnectionCanBeUsedFor(s.Value, address, authenticated, topic)).Select(x => x.Value); // Don't ToList this so the query is executed again when called
 
             // If all current socket connections are reconnecting or resubscribing wait for that to finish as we can probably use the existing connection
             var delayStart = DateTime.UtcNow;
@@ -916,11 +858,9 @@ namespace CryptoExchange.Net.Clients
                 ReconnectInterval = ClientOptions.ReconnectInterval,
                 RateLimiter = ClientOptions.RateLimiterEnabled ? RateLimiter : null,
                 RateLimitingBehavior = ClientOptions.RateLimitingBehaviour,
-                RateLimitAdmissionCallbackOptions = (def, weight) => ClientOptions.RateLimitAdmission?.Invoke(def, weight),
-                RateLimitAdmissionCallbackRequest = () => AdmissionOverride.Value,
                 Proxy = ClientOptions.Proxy,
                 Timeout = ApiOptions.SocketNoDataTimeout ?? ClientOptions.SocketNoDataTimeout,
-                ReceiveBufferSize = ClientOptions.ReceiveBufferSize
+                ReceiveBufferSize = ClientOptions.ReceiveBufferSize,
             };
 
         /// <summary>

CryptoExchange.Net/Converters/SystemTextJson/ArrayConverter.cs

@@ -173,9 +173,6 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 
                     if (targetType.IsAssignableFrom(value?.GetType()))
                         attribute.PropertyInfo.SetValue(result, value);
-                    else if (value is string stringValue && targetType == typeof(decimal))
-                        // Convert.ChangeType doesn't accept scientific notation, which some exchanges use for small values ("4.803E-5")
-                        attribute.PropertyInfo.SetValue(result, ExchangeHelpers.ParseDecimal(stringValue));
                     else
                         attribute.PropertyInfo.SetValue(result, value == null ? null : Convert.ChangeType(value, targetType, CultureInfo.InvariantCulture));
                 }

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>13.2.0</PackageVersion>
-    <AssemblyVersion>13.2.0</AssemblyVersion>
-    <FileVersion>13.2.0</FileVersion>
+    <PackageVersion>12.5.1</PackageVersion>
+    <AssemblyVersion>12.5.1</AssemblyVersion>
+    <FileVersion>12.5.1</FileVersion>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>OKX;OKX.Net;Mexc;Mexc.Net;Kucoin;Kucoin.Net;Kraken;Kraken.Net;Huobi;Huobi.Net;CoinEx;CoinEx.Net;Bybit;Bybit.Net;Bitget;Bitget.Net;Bitfinex;Bitfinex.Net;Binance;Binance.Net;CryptoCurrency;CryptoCurrency Exchange;CryptoExchange.Net</PackageTags>
     <RepositoryType>git</RepositoryType>

CryptoExchange.Net/ExtensionMethods.cs

@@ -1,8 +1,5 @@
-using CryptoExchange.Net.Clients;
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Interfaces.Clients;
+using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.RateLimiting;
 using CryptoExchange.Net.SharedApis;
 using Microsoft.Extensions.DependencyInjection;
 using System;
@@ -14,7 +11,6 @@ using System.IO.Compression;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
-using System.Threading.Tasks;
 using System.Web;
 
 namespace CryptoExchange.Net
@@ -150,42 +146,25 @@ namespace CryptoExchange.Net
         /// <returns></returns>
         public static string ToFormData(this IDictionary<string, object> parameters)
         {
-            var result = new StringBuilder();
-            var first = true;
-
-            void Append(string key, object value)
-            {
-                if (!first)
-                    result.Append('&');
-                first = false;
-
-                if (!string.IsNullOrEmpty(key))
-                {
-                    result.Append(HttpUtility.UrlEncode(key, Encoding.UTF8));
-                    result.Append('=');
-                }
-
-                var text = string.Format(CultureInfo.InvariantCulture, "{0}", value);
-                result.Append(HttpUtility.UrlEncode(text, Encoding.UTF8));
-            }
-
+            var formData = HttpUtility.ParseQueryString(string.Empty);
             foreach (var kvp in parameters)
             {
                 if (kvp.Value is null)
                     continue;
 
-                if (kvp.Value is Array array)
+                if (kvp.Value.GetType().IsArray)
                 {
+                    var array = (Array)kvp.Value;
                     foreach (var value in array)
-                        Append(kvp.Key, value);
+                        formData.Add(kvp.Key, string.Format(CultureInfo.InvariantCulture, "{0}", value));
                 }
                 else
                 {
-                    Append(kvp.Key, kvp.Value);
+                    formData.Add(kvp.Key, string.Format(CultureInfo.InvariantCulture, "{0}", kvp.Value));
                 }
             }
 
-            return result.ToString();
+            return formData.ToString()!;
         }
 
         /// <summary>
@@ -409,14 +388,15 @@ namespace CryptoExchange.Net
                 services.AddTransient(x => (ITradeHistoryRestClient)client(x)!);
             if (typeof(IWithdrawalRestClient).IsAssignableFrom(typeof(T)))
                 services.AddTransient(x => (IWithdrawalRestClient)client(x)!);
-            if (typeof(IWithdrawRestClient).IsAssignableFrom(typeof(T)))
-                services.AddTransient(x => (IWithdrawRestClient)client(x)!);
+            if (typeof(IWithdrawEndpoint).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IWithdrawEndpoint)client(x)!);
             if (typeof(IFeeRestClient).IsAssignableFrom(typeof(T)))
                 services.AddTransient(x => (IFeeRestClient)client(x)!);
             if (typeof(IBookTickerRestClient).IsAssignableFrom(typeof(T)))
                 services.AddTransient(x => (IBookTickerRestClient)client(x)!);
-            if (typeof(ITransferRestClient).IsAssignableFrom(typeof(T)))
-                services.AddTransient(x => (ITransferRestClient)client(x)!);
+            if (typeof(ITransferEndpoint).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ITransferEndpoint)client(x)!);
+
             if (typeof(ISpotOrderRestClient).IsAssignableFrom(typeof(T)))
                 services.AddTransient(x => (ISpotOrderRestClient)client(x)!);
             if (typeof(ISpotSymbolRestClient).IsAssignableFrom(typeof(T)))
@@ -495,6 +475,47 @@ namespace CryptoExchange.Net
             return services;
         }
 
+        /// <summary>
+        /// Registers a strict Shared API aggregate and all capability interfaces implemented by it.
+        /// </summary>
+        public static IServiceCollection RegisterSharedApi<
+#if NET5_0_OR_GREATER
+            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
+#endif
+        TSharedApi>(
+            this IServiceCollection services,
+            Func<IServiceProvider, TSharedApi> factory)
+            where TSharedApi : class, ISharedApi
+        {
+            services.AddTransient<TSharedApi>(factory);
+
+            var markerInterfaces = new[]
+            {
+                typeof(ISharedApiCapability),
+                typeof(ISharedApiEndpoint),
+                typeof(ISharedSocketOperation),
+                typeof(ISharedSubscription)
+            };
+
+            var capabilityInterfaces = typeof(TSharedApi)
+                .GetInterfaces()
+                .Where(x =>
+                    typeof(ISharedApiCapability).IsAssignableFrom(x)
+                    && !markerInterfaces.Contains(x))
+                .Distinct()
+                .ToArray();
+
+            foreach (var capabilityInterface in capabilityInterfaces)
+            {
+                services.AddTransient(
+                    capabilityInterface,
+                    serviceProvider =>
+                        serviceProvider.GetRequiredService<TSharedApi>());
+            }
+
+            return services;
+        }
+
         /// <summary>
         /// Convert a hex encoded string to byte array
         /// </summary>
@@ -514,41 +535,6 @@ namespace CryptoExchange.Net
 
             return bytes;
         }
-
-        /// <summary>
-        /// Execute an operation with a specific rate limit admission rule
-        /// </summary>
-        /// <param name="client">Client</param>
-        /// <param name="admission">Rate limit admission rule</param>
-        /// <param name="operation">Operation to execute</param>
-        public static Task<TResult> WithRateLimitAdmissionAsync<TClient, TResult>(
-            this TClient client,
-            RateLimitAdmission admission,
-            Func<TClient, Task<TResult>> operation)
-            where TClient : IRateLimitAdmissionClient
-        {
-            return client.WithRateLimitAdmissionAsync(
-                admission,
-                () => operation(client));
-        }
-
-
-        /// <summary>
-        /// Return the task results in the form of an IAsyncEnumerable, returning the first completed task first
-        /// </summary>
-        /// <typeparam name="T">Type of task result</typeparam>
-        /// <param name="tasks">Task list</param>
-        public static async IAsyncEnumerable<T> ParallelEnumerateAsync<T>(this IEnumerable<Task<T>> tasks)
-        {
-            var remaining = new List<Task<T>>(tasks);
-
-            while (remaining.Count != 0)
-            {
-                var task = await Task.WhenAny(remaining).ConfigureAwait(false);
-                remaining.Remove(task);
-                yield return await task.ConfigureAwait(false);
-            }
-        }
     }
 }
 

CryptoExchange.Net/Interfaces/Clients/IBaseApiClient.cs

@@ -1,4 +1,6 @@
-using CryptoExchange.Net.SharedApis;
+using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.SharedApis;
 using System;
 
 namespace CryptoExchange.Net.Interfaces.Clients
@@ -6,7 +8,7 @@ namespace CryptoExchange.Net.Interfaces.Clients
     /// <summary>
     /// Base api client
     /// </summary>
-    public interface IBaseApiClient : IRateLimitAdmissionClient
+    public interface IBaseApiClient
     {
         /// <summary>
         /// Exchange name

CryptoExchange.Net/Interfaces/IRateLimitAdmissionClient.cs

@@ -1,22 +0,0 @@
-using CryptoExchange.Net.RateLimiting;
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.Interfaces
-{
-    /// <summary>
-    /// A client supporting rate limit admission rules
-    /// </summary>
-    public interface IRateLimitAdmissionClient
-    {
-        /// <summary>
-        /// Execute an operation with a specific rate limit admission rule
-        /// </summary>
-        Task<TResult> WithRateLimitAdmissionAsync<TResult>(
-            RateLimitAdmission admission,
-            Func<Task<TResult>> operation);
-    }
-
-}

CryptoExchange.Net/Objects/Options/ExchangeOptions.cs

@@ -1,5 +1,4 @@
 using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.RateLimiting;
 using System;
 
 namespace CryptoExchange.Net.Objects.Options
@@ -42,12 +41,6 @@ namespace CryptoExchange.Net.Objects.Options
         /// </summary>
         public RateLimitingBehaviour RateLimitingBehaviour { get; set; } = RateLimitingBehaviour.Wait;
 
-        /// <summary>
-        /// A delegate receiving the request definition and the request weight that can be used to determine whether a request should be admitted or rejected based 
-        /// on the request definition and the current rate limit usage ratio. This allows for custom rate limiting logic to be implemented.
-        /// </summary>
-        public Func<RequestDefinition, int, RateLimitAdmission>? RateLimitAdmission { get; set; }
-
         /// <inheritdoc />
         public override string ToString()
         {

CryptoExchange.Net/Objects/Options/RestExchangeOptions.cs

@@ -75,7 +75,6 @@ namespace CryptoExchange.Net.Objects.Options
             item.RateLimiterEnabled = RateLimiterEnabled;
             item.RateLimitingBehaviour = RateLimitingBehaviour;
             item.RateLimitGroup = RateLimitGroup;
-            item.RateLimitAdmission = RateLimitAdmission;
             item.CachingEnabled = CachingEnabled;
             item.CachingMaxAge = CachingMaxAge;
             item.HttpVersion = HttpVersion;

CryptoExchange.Net/Objects/Options/SocketApiOptions.cs

@@ -19,11 +19,6 @@ namespace CryptoExchange.Net.Objects.Options
         /// </summary>
         public int? MaxSocketConnections { get; set; }
 
-        /// <summary>
-        /// The time to wait after connecting a socket before sending messages. Can be used for API's which will rate limit if you subscribe directly after connecting.
-        /// </summary>
-        public TimeSpan? DelayAfterConnect { get; set; }
-
         /// <summary>
         /// Set the values of this options on the target options
         /// </summary>
@@ -33,7 +28,6 @@ namespace CryptoExchange.Net.Objects.Options
             item.SocketNoDataTimeout = SocketNoDataTimeout;
             item.AutoTimestamp = AutoTimestamp;
             item.MaxSocketConnections = MaxSocketConnections;
-            item.DelayAfterConnect = DelayAfterConnect;
             return item;
         }
     }

CryptoExchange.Net/Objects/Options/SocketExchangeOptions.cs

@@ -105,7 +105,6 @@ namespace CryptoExchange.Net.Objects.Options
             item.RateLimitingBehaviour = RateLimitingBehaviour;
             item.RateLimiterEnabled = RateLimiterEnabled;
             item.RateLimitGroup = RateLimitGroup;
-            item.RateLimitAdmission = RateLimitAdmission;
             item.ReceiveBufferSize = ReceiveBufferSize;
             return item;
         }

CryptoExchange.Net/Objects/Results/CallResult.cs

@@ -97,7 +97,7 @@ public record CallResult<T> : CallResult, ICallResult<T>
 /// Call result for an exchange
 /// </summary>
 /// <typeparam name="T">Data type</typeparam>
-public record ExchangeCallResult<T> : CallResult<T>, IExchangeCallResult<T>
+public record ExchangeCallResult<T> : CallResult<T>
 {
     /// <summary>
     /// Exchange name

CryptoExchange.Net/Objects/Results/ICallResult.cs

@@ -40,23 +40,4 @@ public interface ICallResult<T> : ICallResult
     /// The result data, only available when Success = true
     /// </summary>
     T? Data { get; }
-}
-
-/// <summary>
-/// Exchange call result
-/// </summary>
-public interface IExchangeCallResult : ICallResult
-{
-    /// <summary>
-    /// Exchange name
-    /// </summary>
-    public string Exchange { get; }
-}
-
-/// <summary>
-/// Exchange call result
-/// </summary>
-/// <typeparam name="T">Result data type</typeparam>
-public interface IExchangeCallResult<T> : IExchangeCallResult, ICallResult<T>
-{
 }

CryptoExchange.Net/Objects/Results/IHttpResult.cs

@@ -10,8 +10,12 @@ namespace CryptoExchange.Net.Objects
     /// <summary>
     /// HTTP call result
     /// </summary>
-    public interface IHttpResult : ICallResult, IExchangeCallResult
+    public interface IHttpResult : ICallResult
     {
+        /// <summary>
+        /// Exchange name
+        /// </summary>
+        string Exchange { get; init; }
         /// <summary>
         /// The original data returned by the call, only available when `OutputOriginalData` is set to `true` in the client options
         /// </summary>
@@ -75,7 +79,7 @@ namespace CryptoExchange.Net.Objects
     /// HTTP call result
     /// </summary>
     /// <typeparam name="T">Result data type</typeparam>
-    public interface IHttpResult<T> : IHttpResult, IExchangeCallResult<T>
+    public interface IHttpResult<T> : IHttpResult, ICallResult<T>
     {
     }
 }

CryptoExchange.Net/Objects/Results/IWebSocketResult.cs

@@ -10,8 +10,13 @@ namespace CryptoExchange.Net.Objects
     /// <summary>
     /// WebSocket call result
     /// </summary>
-    public interface IWebSocketResult : ICallResult, IExchangeCallResult
+    public interface IWebSocketResult : ICallResult
     {
+        /// <summary>
+        /// Exchange name
+        /// </summary>
+        string Exchange { get; init; }
+
         /// <summary>
         /// The request id
         /// </summary>
@@ -37,7 +42,7 @@ namespace CryptoExchange.Net.Objects
     /// WebSocket call result
     /// </summary>
     /// <typeparam name="T">Data result type</typeparam>
-    public interface IWebSocketResult<T> : IWebSocketResult, IExchangeCallResult<T>
+    public interface IWebSocketResult<T> : IWebSocketResult, ICallResult<T>
     {
 
     }

CryptoExchange.Net/Objects/Sockets/WebSocketParameters.cs

@@ -1,5 +1,4 @@
-using CryptoExchange.Net.RateLimiting;
-using CryptoExchange.Net.RateLimiting.Interfaces;
+using CryptoExchange.Net.RateLimiting.Interfaces;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -65,17 +64,6 @@ namespace CryptoExchange.Net.Objects.Sockets
         /// </summary>
         public RateLimitingBehaviour RateLimitingBehavior { get; set; }
 
-        /// <summary>
-        /// A delegate receiving the request definition and the request weight that can be used to determine whether a request should be admitted or rejected based 
-        /// on the request definition and the current rate limit usage ratio. This allows for custom rate limiting logic to be implemented.
-        /// </summary>
-        public Func<RequestDefinition, int, RateLimitAdmission?>? RateLimitAdmissionCallbackOptions { get; set; }
-
-        /// <summary>
-        /// A delegate for retrieving the current rate limit admission decision for a specific request. This allows for custom rate limiting logic to be implemented.
-        /// </summary>
-        public Func<RateLimitAdmission?>? RateLimitAdmissionCallbackRequest { get; set; }
-
         /// <summary>
         /// Encoding for sending/receiving data
         /// </summary>

CryptoExchange.Net/RateLimiting/Guards/RateLimitGuard.cs

@@ -36,7 +36,6 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         private readonly Dictionary<string, IWindowTracker> _trackers;
         private readonly RateLimitWindowType _windowType;
         private readonly double? _decayRate;
-        private readonly TimeSpan _safetyMargin;
         private readonly int? _connectionWeight;
         private readonly Func<RequestDefinition, string?, string> _keySelector;
         private readonly SemaphoreSlim? _sharedGuardSemaphore;
@@ -55,10 +54,6 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         /// The time period for the limit
         /// </summary>
         public TimeSpan TimeSpan { get; }
-        /// <summary>
-        /// Additional time to wait after a rate limit window expires to account for latency and timing differences
-        /// </summary>
-        public TimeSpan SafetyMargin => _safetyMargin;
 
         /// <summary>
         /// Whether this guard is shared between multiple gates
@@ -73,12 +68,11 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         /// <param name="limit">Limit per period</param>
         /// <param name="timeSpan">Timespan for the period</param>
         /// <param name="windowType">Type of rate limit window</param>
-        /// <param name="safetyMargin">Additional time to wait after a window expires, or null to use the default margin</param>
         /// <param name="decayPerTimeSpan">The decay per timespan if windowType is DecayWindowTracker</param>
         /// <param name="connectionWeight">The weight of a new connection</param>
         /// <param name="shared">Whether this guard is shared between multiple gates</param>
-        public RateLimitGuard(Func<RequestDefinition, string?, string> keySelector, IGuardFilter filter, int limit, TimeSpan timeSpan, RateLimitWindowType windowType, double? decayPerTimeSpan = null, int? connectionWeight = null, bool shared = false, TimeSpan? safetyMargin = null)
-            : this(keySelector, new[] { filter }, limit, timeSpan, windowType, decayPerTimeSpan, connectionWeight, shared, safetyMargin)
+        public RateLimitGuard(Func<RequestDefinition, string?, string> keySelector, IGuardFilter filter, int limit, TimeSpan timeSpan, RateLimitWindowType windowType, double? decayPerTimeSpan = null, int? connectionWeight = null, bool shared = false)
+            : this(keySelector, new[] { filter }, limit, timeSpan, windowType, decayPerTimeSpan, connectionWeight, shared)
         {
         }
 
@@ -90,11 +84,10 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         /// <param name="limit">Limit per period</param>
         /// <param name="timeSpan">Timespan for the period</param>
         /// <param name="windowType">Type of rate limit window</param>
-        /// <param name="safetyMargin">Additional time to wait after a window expires, or null to use the default margin</param>
         /// <param name="decayPerTimeSpan">The decay per timespan if windowType is DecayWindowTracker</param>
         /// <param name="connectionWeight">The weight of a new connection</param>
         /// <param name="shared">Whether this guard is shared between multiple gates</param>
-        public RateLimitGuard(Func<RequestDefinition, string?, string> keySelector, IEnumerable<IGuardFilter> filters, int limit, TimeSpan timeSpan, RateLimitWindowType windowType, double? decayPerTimeSpan = null, int? connectionWeight = null, bool shared = false, TimeSpan? safetyMargin = null)
+        public RateLimitGuard(Func<RequestDefinition, string?, string> keySelector, IEnumerable<IGuardFilter> filters, int limit, TimeSpan timeSpan, RateLimitWindowType windowType, double? decayPerTimeSpan = null, int? connectionWeight = null, bool shared = false)
         {
             _filters = filters;
             _trackers = new Dictionary<string, IWindowTracker>();
@@ -104,7 +97,6 @@ namespace CryptoExchange.Net.RateLimiting.Guards
             SharedGuard = shared;
             _keySelector = keySelector;
             _decayRate = decayPerTimeSpan;
-            _safetyMargin = safetyMargin ?? WindowTrackerHelpers.GetDefaultSafetyMargin(timeSpan); ;
             _connectionWeight = connectionWeight;
 
             if (SharedGuard)
@@ -112,7 +104,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         }
 
         /// <inheritdoc />
-        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string? apiKey, int requestWeight, string? keySuffix, double allowedRateRatio)
+        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string? apiKey, int requestWeight, string? keySuffix)
         {
             foreach (var filter in _filters)
             {
@@ -135,7 +127,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
                     _trackers.Add(key, tracker);
                 }
 
-                var delay = tracker.GetWaitTime(requestWeight, allowedRateRatio);
+                var delay = tracker.GetWaitTime(requestWeight);
                 if (delay == default)
                     return LimitCheck.NotNeeded(Limit, TimeSpan, tracker.Current);
 
@@ -213,9 +205,9 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         /// <returns></returns>
         protected IWindowTracker CreateTracker()
         {
-            return _windowType == RateLimitWindowType.Sliding ? new SlidingWindowTracker(Limit, TimeSpan, _safetyMargin)
-                : _windowType == RateLimitWindowType.Fixed ? new FixedWindowTracker(Limit, TimeSpan, _safetyMargin)
-                : _windowType == RateLimitWindowType.FixedAfterFirst ? new FixedAfterStartWindowTracker(Limit, TimeSpan, _safetyMargin) :
+            return _windowType == RateLimitWindowType.Sliding ? new SlidingWindowTracker(Limit, TimeSpan)
+                : _windowType == RateLimitWindowType.Fixed ? new FixedWindowTracker(Limit, TimeSpan)
+                : _windowType == RateLimitWindowType.FixedAfterFirst ? new FixedAfterStartWindowTracker(Limit, TimeSpan) :
                 new DecayWindowTracker(Limit, TimeSpan, _decayRate ?? throw new InvalidOperationException("Decay rate not provided"));
         }
     }

CryptoExchange.Net/RateLimiting/Guards/RetryAfterGuard.cs

@@ -42,7 +42,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         }
 
         /// <inheritdoc />
-        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string? apiKey, int requestWeight, string? keySuffix, double allowedRateRatio)
+        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string? apiKey, int requestWeight, string? keySuffix)
         {
             if (type != Type)
                 return LimitCheck.NotApplicable;

CryptoExchange.Net/RateLimiting/Guards/SingleLimitGuard.cs

@@ -24,7 +24,6 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         private readonly Dictionary<string, IWindowTracker> _trackers;
         private readonly RateLimitWindowType _windowType;
         private readonly double? _decayRate;
-        private readonly TimeSpan _safetyMargin;
         private readonly int _limit;
         private readonly TimeSpan _period;
         private readonly Func<RequestDefinition, string?, string> _keySelector;
@@ -33,12 +32,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         public string Name => "EndpointLimitGuard";
 
         /// <inheritdoc />
-        public string Description => _windowType == RateLimitWindowType.Decay ? $"Endpoint limit of {_limit} with a decay rate of {_decayRate}" : $"Limit of {_limit} per {_period}";
-
-        /// <summary>
-        /// Additional time to wait after a rate limit window expires to account for latency and timing differences
-        /// </summary>
-        public TimeSpan SafetyMargin => _safetyMargin;
+        public string Description => $"Limit requests to endpoint";
 
         /// <summary>
         /// ctor
@@ -47,21 +41,19 @@ namespace CryptoExchange.Net.RateLimiting.Guards
             int limit,
             TimeSpan period,
             RateLimitWindowType windowType,
-            TimeSpan? safetyMargin = null,
-            Func<RequestDefinition, string?, string>? keySelector = null,
-            double? decayRate = null)
+            double? decayRate = null,
+            Func<RequestDefinition, string?, string>? keySelector = null)
         {
             _limit = limit;
             _period = period;
             _windowType = windowType;
             _decayRate = decayRate;
-            _safetyMargin = safetyMargin ?? WindowTrackerHelpers.GetDefaultSafetyMargin(period);
             _keySelector = keySelector ?? Default;
             _trackers = new Dictionary<string, IWindowTracker>();
         }
 
         /// <inheritdoc />
-        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string? apiKey, int requestWeight, string? keySuffix, double allowedRateRatio)
+        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string? apiKey, int requestWeight, string? keySuffix)
         {
             var key = _keySelector(definition, apiKey) + keySuffix;
             if (!_trackers.TryGetValue(key, out var tracker))
@@ -70,7 +62,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
                 _trackers.Add(key, tracker);
             }
 
-            var delay = tracker.GetWaitTime(requestWeight, allowedRateRatio);
+            var delay = tracker.GetWaitTime(requestWeight);
             if (delay == default)
                 return LimitCheck.NotNeeded(_limit, _period, tracker.Current);
 
@@ -92,8 +84,8 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         /// <returns></returns>
         protected IWindowTracker CreateTracker()
         {
-            return _windowType == RateLimitWindowType.Sliding ? new SlidingWindowTracker(_limit, _period, _safetyMargin)
-                : _windowType == RateLimitWindowType.Fixed ? new FixedWindowTracker(_limit, _period, _safetyMargin) :
+            return _windowType == RateLimitWindowType.Sliding ? new SlidingWindowTracker(_limit, _period)
+                : _windowType == RateLimitWindowType.Fixed ? new FixedWindowTracker(_limit, _period) :
                 new DecayWindowTracker(_limit, _period, _decayRate ?? throw new InvalidOperationException("Decay rate not provided"));
         }
 

CryptoExchange.Net/RateLimiting/Interfaces/IRateLimitGate.cs

@@ -53,20 +53,9 @@ namespace CryptoExchange.Net.RateLimiting.Interfaces
         /// <param name="requestWeight">Request weight</param>
         /// <param name="behaviour">Behaviour when rate limit is hit</param>
         /// <param name="keySuffix">An additional optional suffix for the key selector. Can be used to make rate limiting work based on parameters.</param>
-        /// <param name="allowedRateRatio">The allowed rate ratio</param>
-        /// <param name="ct">Cancellation token</param>
+        /// <param name="ct">Cancelation token</param>
         /// <returns>Error if RateLimitingBehaviour is Fail and rate limit is hit</returns>
-        ValueTask<CallResult> ProcessAsync(
-            ILogger logger,
-            int itemId, 
-            RateLimitItemType type, 
-            RequestDefinition definition,
-            string? apiKey, 
-            int requestWeight, 
-            RateLimitingBehaviour behaviour,
-            string? keySuffix,
-            double allowedRateRatio,
-            CancellationToken ct);
+        ValueTask<CallResult> ProcessAsync(ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string? apiKey, int requestWeight, RateLimitingBehaviour behaviour, string? keySuffix, CancellationToken ct);
 
         /// <summary>
         /// Enforces the rate limit as defined in the request definition. When a rate limit is hit will wait for the rate limit to pass if RateLimitingBehaviour is Wait, or return an error if it is set to Fail
@@ -80,21 +69,9 @@ namespace CryptoExchange.Net.RateLimiting.Interfaces
         /// <param name="behaviour">Behaviour when rate limit is hit</param>
         /// <param name="requestWeight">The weight to apply to the limit guard</param>
         /// <param name="keySuffix">An additional optional suffix for the key selector. Can be used to make rate limiting work based on parameters.</param>
-        /// <param name="allowedRateRatio">The allowed rate ratio</param>
         /// <param name="ct">Cancelation token</param>
         /// <returns>Error if RateLimitingBehaviour is Fail and rate limit is hit</returns>
-        ValueTask<CallResult> ProcessSingleAsync(
-            ILogger logger, 
-            int itemId, 
-            IRateLimitGuard guard, 
-            RateLimitItemType type, 
-            RequestDefinition definition, 
-            string? apiKey, 
-            int requestWeight, 
-            RateLimitingBehaviour behaviour, 
-            string? keySuffix,
-            double allowedRateRatio,
-            CancellationToken ct);
+        ValueTask<CallResult> ProcessSingleAsync(ILogger logger, int itemId, IRateLimitGuard guard, RateLimitItemType type, RequestDefinition definition, string? apiKey, int requestWeight, RateLimitingBehaviour behaviour, string? keySuffix, CancellationToken ct);
 
         /// <summary>
         /// Reset the limit for the specified parameters

CryptoExchange.Net/RateLimiting/Interfaces/IRateLimitGuard.cs

@@ -25,9 +25,8 @@ namespace CryptoExchange.Net.RateLimiting.Interfaces
         /// <param name="apiKey">The API key</param>
         /// <param name="requestWeight">The request weight</param>
         /// <param name="keySuffix">An additional optional suffix for the key selector. Can be used to make rate limiting work based on parameters.</param>
-        /// <param name="allowedRateRatio">The allowed rate ratio</param>
         /// <returns></returns>
-        LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string? apiKey, int requestWeight, string? keySuffix, double allowedRateRatio);
+        LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string? apiKey, int requestWeight, string? keySuffix);
 
         /// <summary>
         /// Apply the request to this guard with the specified weight

CryptoExchange.Net/RateLimiting/Interfaces/IWindowTracker.cs

@@ -22,7 +22,9 @@ namespace CryptoExchange.Net.RateLimiting.Interfaces
         /// <summary>
         /// Get the time to wait to fit the weight
         /// </summary>
-        TimeSpan GetWaitTime(int weight, double allowedRateRatio);
+        /// <param name="weight"></param>
+        /// <returns></returns>
+        TimeSpan GetWaitTime(int weight);
         /// <summary>
         /// Register the weight in this window
         /// </summary>

CryptoExchange.Net/RateLimiting/RateLimitAdmission.cs

@@ -1,32 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.RateLimiting
-{
-    /// <summary>
-    /// Rate limit admission decision result
-    /// </summary>
-    public record RateLimitAdmission
-    {
-        /// <summary>
-        /// Value ratio between 0 and 1
-        /// </summary>
-        public double MaxUtilizationRatio { get; }
-
-        private RateLimitAdmission(double maxUtilizationValue) { 
-            if (maxUtilizationValue <= 0 || maxUtilizationValue > 1)
-                throw new ArgumentOutOfRangeException(nameof(maxUtilizationValue), "Max utilization value must be bigger than 0 and less than or equal to 1");
-
-            MaxUtilizationRatio = maxUtilizationValue;
-        }
-
-        /// <summary>
-        /// Only allow the request when below a certain ratio of the rate limit, for example 0.5 means it can use a max of 50% of the rate limit, 
-        /// 1 means it's allowed to use the full rate limit.
-        /// </summary>
-        /// <param name="value">0.5 means a max use 50% of the rate limit, 1 means the request is allowed to use the full rate limit</param>
-        public static RateLimitAdmission WithMaxUtilizationRatio(double value)
-            => new RateLimitAdmission(value);
-    }
-}

CryptoExchange.Net/RateLimiting/RateLimitGate.cs

@@ -37,24 +37,14 @@ namespace CryptoExchange.Net.RateLimiting
         }
 
         /// <inheritdoc />
-        public async ValueTask<CallResult> ProcessAsync(
-            ILogger logger,
-            int itemId,
-            RateLimitItemType type,
-            RequestDefinition definition, 
-            string? apiKey, 
-            int requestWeight, 
-            RateLimitingBehaviour rateLimitingBehaviour, 
-            string? keySuffix, 
-            double allowedRateRatio,
-            CancellationToken ct)
+        public async ValueTask<CallResult> ProcessAsync(ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string? apiKey, int requestWeight, RateLimitingBehaviour rateLimitingBehaviour, string? keySuffix, CancellationToken ct)
         {
             await _semaphore.WaitAsync(ct).ConfigureAwait(false);
             bool release = true;
             _waitingCount++;
             try
             {
-                return await CheckGuardsAsync(_guards, logger, itemId, type, definition, apiKey, requestWeight, rateLimitingBehaviour, keySuffix, allowedRateRatio, ct).ConfigureAwait(false);
+                return await CheckGuardsAsync(_guards, logger, itemId, type, definition, apiKey, requestWeight, rateLimitingBehaviour, keySuffix, ct).ConfigureAwait(false);
             }
             catch (TaskCanceledException tce)
             {
@@ -81,7 +71,6 @@ namespace CryptoExchange.Net.RateLimiting
              int requestWeight,
             RateLimitingBehaviour rateLimitingBehaviour,
             string? keySuffix,
-            double allowedRateRatio,
             CancellationToken ct)
         {
             await _semaphore.WaitAsync(ct).ConfigureAwait(false);
@@ -89,7 +78,7 @@ namespace CryptoExchange.Net.RateLimiting
             _waitingCount++;
             try
             {
-                return await CheckGuardsAsync(new IRateLimitGuard[] { guard }, logger, itemId, type, definition, apiKey, requestWeight, rateLimitingBehaviour, keySuffix, allowedRateRatio, ct).ConfigureAwait(false);
+                return await CheckGuardsAsync(new IRateLimitGuard[] { guard }, logger, itemId, type, definition, apiKey, requestWeight, rateLimitingBehaviour, keySuffix, ct).ConfigureAwait(false);
             }
             catch (TaskCanceledException tce)
             {
@@ -105,23 +94,12 @@ namespace CryptoExchange.Net.RateLimiting
             }
         }
 
-        private async ValueTask<CallResult> CheckGuardsAsync(
-            IEnumerable<IRateLimitGuard> guards,
-            ILogger logger,
-            int itemId,
-            RateLimitItemType type,
-            RequestDefinition definition,
-            string? apiKey,
-            int requestWeight, 
-            RateLimitingBehaviour rateLimitingBehaviour, 
-            string? keySuffix, 
-            double allowedRateRatio,
-            CancellationToken ct)
+        private async ValueTask<CallResult> CheckGuardsAsync(IEnumerable<IRateLimitGuard> guards, ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string? apiKey, int requestWeight, RateLimitingBehaviour rateLimitingBehaviour, string? keySuffix, CancellationToken ct)
         {
             foreach (var guard in guards)
             {
                 // Check if a wait is needed for this guard
-                var result = guard.Check(type, definition, apiKey, requestWeight, keySuffix, allowedRateRatio);
+                var result = guard.Check(type, definition, apiKey, requestWeight, keySuffix);
                 if (result.Delay != TimeSpan.Zero && rateLimitingBehaviour == RateLimitingBehaviour.Fail)
                 {
                     // Delay is needed and limit behaviour is to fail the request
@@ -131,10 +109,7 @@ namespace CryptoExchange.Net.RateLimiting
                         logger.RateLimitRequestFailed(itemId, definition.Path, guard.Name, guard.Description);
                     
                     RateLimitTriggered?.Invoke(new RateLimitEvent(itemId, _name, guard.Description, definition, result.Current, requestWeight, result.Limit, result.Period, result.Delay, rateLimitingBehaviour));
-                    var errorMsg = $"Rate limit check failed on guard {guard.Name}; {guard.Description}";
-                    if (allowedRateRatio < 1)
-                        errorMsg += $" with allowed ratio {allowedRateRatio}";
-                    return CallResult.Fail(new ClientRateLimitError(errorMsg));
+                    return CallResult.Fail(new ClientRateLimitError($"Rate limit check failed on guard {guard.Name}; {guard.Description}"));
                 }
 
                 if (result.Delay != TimeSpan.Zero)
@@ -142,14 +117,7 @@ namespace CryptoExchange.Net.RateLimiting
                     // Delay is needed and limit behaviour is to wait for the request to be under the limit
                     _semaphore.Release();
 
-                    var description = 
-                        result.Limit == null 
-                            ? guard.Description 
-                            : $"{guard.Description}, Request weight: {requestWeight}," +
-                                $" Current: {result.Current}" +
-                                $", Limit: {result.Limit}" +
-                                (allowedRateRatio < 1 ? $", Allowed ratio: {allowedRateRatio}" : "") +
-                                $", requests now being limited: {_waitingCount}";
+                    var description = result.Limit == null ? guard.Description : $"{guard.Description}, Request weight: {requestWeight}, Current: {result.Current}, Limit: {result.Limit}, requests now being limited: {_waitingCount}";
                     if (type == RateLimitItemType.Connection)
                         logger.RateLimitDelayingConnection(itemId, result.Delay, guard.Name, description);
                     else
@@ -158,7 +126,7 @@ namespace CryptoExchange.Net.RateLimiting
                     RateLimitTriggered?.Invoke(new RateLimitEvent(itemId, _name, guard.Description, definition, result.Current, requestWeight, result.Limit, result.Period, result.Delay, rateLimitingBehaviour));
                     await Task.Delay((int)result.Delay.TotalMilliseconds + 1, ct).ConfigureAwait(false);
                     await _semaphore.WaitAsync(ct).ConfigureAwait(false);
-                    return await CheckGuardsAsync(guards, logger, itemId, type, definition, apiKey, requestWeight, rateLimitingBehaviour, keySuffix, allowedRateRatio, ct).ConfigureAwait(false);
+                    return await CheckGuardsAsync(guards, logger, itemId, type, definition, apiKey, requestWeight, rateLimitingBehaviour, keySuffix, ct).ConfigureAwait(false);
                 }
             }
 

CryptoExchange.Net/RateLimiting/Trackers/DecayWindowTracker.cs

@@ -18,18 +18,9 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
 
         private int _currentWeight = 0;
         private DateTime _lastDecrease = DateTime.UtcNow;
-        private double _decayProgress;
 
-        public DecayWindowTracker(
-            int limit,
-            TimeSpan period,
-            double decayRate)
+        public DecayWindowTracker(int limit, TimeSpan period, double decayRate)
         {
-            if (period <= TimeSpan.Zero)
-                throw new ArgumentOutOfRangeException(nameof(period));
-
-            if (decayRate <= 0)
-                throw new ArgumentOutOfRangeException(nameof(decayRate));
             Limit = limit;
             TimePeriod = period;
             DecreaseRate = decayRate;
@@ -39,119 +30,74 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
         public void Reset(int? amount)
         {
             if (amount == null)
-            {
-                ResetState();
-                return;
-            }
-
-            _currentWeight = Math.Max(0, _currentWeight - amount.Value);
-            if (_currentWeight == 0)
-                ResetState();
-        }
-
-        /// <inheritdoc />
-        public TimeSpan GetWaitTime(int weight, double allowedRateRatio)
-        {
-            var now = DateTime.UtcNow;
-            DecreaseCounter(now);
-
-            if ((Current + weight) / (double)Limit <= allowedRateRatio)
-                return TimeSpan.Zero;
-
-            if (Current == 0)
-            {
-                if (allowedRateRatio < 1)
-                {
-                    throw new Exception(
-                        "Request limit reached max utilization. " +
-                        "This request can never execute with the current rate limiter configuration. " +
-                        $"Request weight: {weight}, RateLimit: {Limit}, " +
-                        $"Request ratio: {(Current + weight) / (double)Limit}, " +
-                        $"AllowedRateRatio: {allowedRateRatio}");
-                }
-
-                throw new Exception(
-                    "Request limit reached without any prior request. " +
-                    "This request can never execute with the current rate limiter. " +
-                    $"Request weight: {weight}, RateLimit: {Limit}");
-            }
-
-            return DetermineWaitTime(
-                weight,
-                allowedRateRatio);
-        }
-
-        public void ApplyWeight(int weight)
-        {
-            if (_currentWeight == 0)
             {
                 _lastDecrease = DateTime.UtcNow;
-                _decayProgress = 0;
-            }
-
-            _currentWeight += weight;
-        }
-
-        private void DecreaseCounter(DateTime now)
-        {
-            if (_currentWeight == 0)
-            {
-                _lastDecrease = now;
-                _decayProgress = 0;
-                return;
-            }
-
-            var elapsed = now - _lastDecrease;
-            if (elapsed <= TimeSpan.Zero)
-                return;
-
-            var elapsedDecay = elapsed.Ticks / (double)TimePeriod.Ticks * DecreaseRate;
-
-            var totalDecay = _decayProgress + elapsedDecay;
-            var completedDecay = (int)Math.Floor(totalDecay);
-
-            _lastDecrease = now;
-
-            if (completedDecay == 0)
-            {
-                _decayProgress = totalDecay;
-                return;
-            }
-
-            _currentWeight = Math.Max(0, _currentWeight - completedDecay);
-            if (_currentWeight == 0)
-            {
-                // Decay cannot accumulate as credit while the counter is empty.
-                _decayProgress = 0;
+                _currentWeight = 0;
             }
             else
             {
-                _decayProgress = totalDecay - completedDecay;
+                _currentWeight = Math.Max(0, _currentWeight - amount.Value);
             }
         }
 
-        private TimeSpan DetermineWaitTime(
-            int requestWeight,
-            double allowedRateRatio)
+        /// <inheritdoc />
+        public TimeSpan GetWaitTime(int weight)
         {
-            var weightToRemove = Current + requestWeight - Limit * allowedRateRatio;
+            // Decrease the counter based on the last update time and decay rate
+            DecreaseCounter(DateTime.UtcNow);
 
-            // The counter is integer-valued, so enough whole weight units
-            // must decay before the request can be admitted.
-            var requiredDecay = Math.Ceiling(weightToRemove);
-            var remainingDecay = Math.Max(0, requiredDecay - _decayProgress);
+            if (Current + weight > Limit)
+            {
+                // The weight would cause the rate limit to be passed
+                if (Current == 0)
+                {
+                    throw new Exception("Request limit reached without any prior request. " +
+                        $"This request can never execute with the current rate limiter. Request weight: {weight}, RateLimit: {Limit}");
+                }
 
-            var waitTicks = Math.Ceiling(remainingDecay / DecreaseRate * TimePeriod.Ticks);
-            return waitTicks <= 0
-                ? TimeSpan.Zero
-                : TimeSpan.FromTicks((long)waitTicks);
+                // Determine the time to wait before this weight can be applied without going over the rate limit
+                return DetermineWaitTime(weight);
+            }
+
+            // Weight can fit without going over limit
+            return TimeSpan.Zero;
         }
 
-        private void ResetState()
+        /// <inheritdoc />
+        public void ApplyWeight(int weight)
         {
-            _currentWeight = 0;
-            _decayProgress = 0;
-            _lastDecrease = DateTime.UtcNow;
+            if (_currentWeight == 0)
+                _lastDecrease = DateTime.UtcNow;
+            _currentWeight += weight;
+        }
+
+        /// <summary>
+        /// Decrease the counter based on time passed since last update and the decay rate
+        /// </summary>
+        /// <param name="time"></param>
+        protected void DecreaseCounter(DateTime time)
+        {
+            var dif = (time - _lastDecrease).TotalMilliseconds / TimePeriod.TotalMilliseconds * DecreaseRate;
+            var decrease = (int)Math.Floor(dif);
+            if (decrease >= 1)
+            {
+                _currentWeight = Math.Max(0, _currentWeight - (int)Math.Floor(dif));
+                _lastDecrease = time;
+            }
+        }
+
+        /// <summary>
+        /// Determine the time to wait before the weight would fit
+        /// </summary>
+        /// <param name="requestWeight"></param>
+        /// <returns></returns>
+        private TimeSpan DetermineWaitTime(int requestWeight)
+        {
+            var weightToRemove = Math.Max(Current - (Limit - requestWeight), 0);
+            var result = TimeSpan.FromMilliseconds(Math.Ceiling(weightToRemove / DecreaseRate) * TimePeriod.TotalMilliseconds);
+            if (result < TimeSpan.Zero)
+                return TimeSpan.Zero;
+            return result;
         }
     }
 }

CryptoExchange.Net/RateLimiting/Trackers/FixedAfterStartWindowTracker.cs

@@ -17,18 +17,15 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
         private int _currentWeight = 0;
         private DateTime? _nextReset;
 
-        private readonly TimeSpan _safetyMargin;
+        /// <summary>
+        /// Additional wait time to apply to account for time offset between server and client
+        /// </summary>
+        private static TimeSpan _fixedWindowBuffer = TimeSpan.FromMilliseconds(1000);
 
         public FixedAfterStartWindowTracker(int limit, TimeSpan period)
-            : this(limit, period, WindowTrackerHelpers.GetDefaultSafetyMargin(period))
-        {
-        }
-
-        public FixedAfterStartWindowTracker(int limit, TimeSpan period, TimeSpan safetyMargin)
         {
             Limit = limit;
             TimePeriod = period;
-            _safetyMargin = safetyMargin;
             _entries = new Queue<LimitEntry>();
         }
 
@@ -56,32 +53,23 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
             }
         }
 
-        public TimeSpan GetWaitTime(int weight, double allowedRateRatio)
+        public TimeSpan GetWaitTime(int weight)
         {
             // Remove requests no longer in time period from the history
             var checkTime = DateTime.UtcNow;
-            if (_nextReset != null && checkTime >= _nextReset + _safetyMargin)
+            if (_nextReset != null && checkTime > _nextReset)
                 RemoveBefore(_nextReset.Value);
 
             if (Current == 0)
                 _nextReset = null;
 
-            if ((Current + weight) / (double)Limit > allowedRateRatio)
+            if (Current + weight > Limit)
             {
                 // The weight would cause the rate limit to be passed
                 if (Current == 0)
                 {
-                    if (allowedRateRatio < 1)
-                    {
-                        throw new Exception("Request limit reached max utilization. " +
-                            $"This request can never execute with the current rate limiter configuration. Request weight: {weight}, RateLimit: {Limit}, " +
-                            $"Request ratio: {(Current + weight) / (double)Limit}, AllowedRateRatio: {allowedRateRatio}");
-                    }
-                    else
-                    {
-                        throw new Exception("Request limit reached without any prior request. " +
-                            $"This request can never execute with the current rate limiter. Request weight: {weight}, RateLimit: {Limit}");
-                    }
+                    throw new Exception("Request limit reached without any prior request. " +
+                        $"This request can never execute with the current rate limiter. Request weight: {weight}, RateLimit: {Limit}");
                 }
 
                 // Determine the time to wait before this weight can be applied without going over the rate limit
@@ -133,7 +121,7 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
         private TimeSpan DetermineWaitTime()
         {
             var checkTime = DateTime.UtcNow;
-            var result = _nextReset!.Value + _safetyMargin - checkTime;
+            var result = (_nextReset!.Value - checkTime) + _fixedWindowBuffer;
             if (result < TimeSpan.Zero)
                 return TimeSpan.Zero;
             return result;

CryptoExchange.Net/RateLimiting/Trackers/FixedWindowTracker.cs

@@ -16,18 +16,15 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
         private readonly Queue<LimitEntry> _entries;
         private int _currentWeight = 0;
 
-        private readonly TimeSpan _safetyMargin;
+        /// <summary>
+        /// Additional wait time to apply to account for time offset between server and client
+        /// </summary>
+        private static readonly TimeSpan _fixedWindowBuffer = TimeSpan.FromMilliseconds(1000);
 
         public FixedWindowTracker(int limit, TimeSpan period)
-            : this(limit, period, WindowTrackerHelpers.GetDefaultSafetyMargin(period))
-        {
-        }
-
-        public FixedWindowTracker(int limit, TimeSpan period, TimeSpan safetyMargin)
         {
             Limit = limit;
             TimePeriod = period;
-            _safetyMargin = safetyMargin;
             _entries = new Queue<LimitEntry>();
         }
 
@@ -55,32 +52,19 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
         }
 
         /// <inheritdoc />
-        public TimeSpan GetWaitTime(int weight, double allowedRateRatio)
+        public TimeSpan GetWaitTime(int weight)
         {
             // Remove requests no longer in time period from the history
             var checkTime = DateTime.UtcNow;
-            var startCurrentWindow = checkTime.AddTicks(-(checkTime.Ticks % TimePeriod.Ticks));
-            var resetBoundary = checkTime >= startCurrentWindow + _safetyMargin
-                ? startCurrentWindow
-                : startCurrentWindow - TimePeriod;
-            RemoveBefore(resetBoundary);
+            RemoveBefore(checkTime.AddTicks(-(checkTime.Ticks % TimePeriod.Ticks)));
 
-            if ((Current + weight) / (double)Limit > allowedRateRatio)
+            if (Current + weight > Limit)
             {
                 // The weight would cause the rate limit to be passed
                 if (Current == 0)
                 {
-                    if (allowedRateRatio < 1)
-                    {
-                        throw new Exception("Request limit reached max utilization. " +
-                            $"This request can never execute with the current rate limiter configuration. Request weight: {weight}, RateLimit: {Limit}, " +
-                            $"Request ratio: {(Current + weight) / (double)Limit}, AllowedRateRatio: {allowedRateRatio}");
-                    }
-                    else
-                    {
-                        throw new Exception("Request limit reached without any prior request. " +
-                            $"This request can never execute with the current rate limiter. Request weight: {weight}, RateLimit: {Limit}");
-                    }
+                    throw new Exception("Request limit reached without any prior request. " +
+                        $"This request can never execute with the current rate limiter. Request weight: {weight}, RateLimit: {Limit}");
                 }
 
                 // Determine the time to wait before this weight can be applied without going over the rate limit
@@ -131,9 +115,8 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
         {
             var checkTime = DateTime.UtcNow;
             var startCurrentWindow = checkTime.AddTicks(-(checkTime.Ticks % TimePeriod.Ticks));
-            var result = checkTime < startCurrentWindow + _safetyMargin
-                ? startCurrentWindow + _safetyMargin - checkTime
-                : startCurrentWindow + TimePeriod + _safetyMargin - checkTime;
+            var wait = startCurrentWindow.Add(TimePeriod) - checkTime;
+            var result = wait.Add(_fixedWindowBuffer);
             if (result < TimeSpan.Zero)
                 return TimeSpan.Zero;
             return result;

CryptoExchange.Net/RateLimiting/Trackers/SlidingWindowTracker.cs

@@ -16,18 +16,15 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
         private readonly List<LimitEntry> _entries;
         private int _currentWeight = 0;
 
-        private readonly TimeSpan _safetyMargin;
+        /// <summary>
+        /// Additional wait time to apply to account for fluctuating request times
+        /// </summary>
+        private static readonly TimeSpan _slidingWindowBuffer = TimeSpan.FromMilliseconds(1000);
 
         public SlidingWindowTracker(int limit, TimeSpan period)
-            : this(limit, period, WindowTrackerHelpers.GetDefaultSafetyMargin(period))
-        {
-        }
-
-        public SlidingWindowTracker(int limit, TimeSpan period, TimeSpan safetyMargin)
         {
             Limit = limit;
             TimePeriod = period;
-            _safetyMargin = safetyMargin;
             _entries = new List<LimitEntry>();
         }
 
@@ -56,31 +53,22 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
         }
 
         /// <inheritdoc />
-        public TimeSpan GetWaitTime(int weight, double allowedRateRatio)
+        public TimeSpan GetWaitTime(int weight)
         {
             // Remove requests no longer in time period from the history
-            RemoveBefore(DateTime.UtcNow - TimePeriod - _safetyMargin);
+            RemoveBefore(DateTime.UtcNow - TimePeriod);
 
-            if ((Current + weight) / (double)Limit > allowedRateRatio)
+            if (Current + weight > Limit)
             {
                 // The weight would cause the rate limit to be passed
                 if (Current == 0)
                 {
-                    if (allowedRateRatio < 1)
-                    {
-                        throw new Exception("Request limit reached max utilization. " +
-                            $"This request can never execute with the current rate limiter configuration. Request weight: {weight}, RateLimit: {Limit}, " +
-                            $"Request ratio: {(Current + weight) / (double)Limit}, AllowedRateRatio: {allowedRateRatio}");
-                    }
-                    else
-                    {
-                        throw new Exception("Request limit reached without any prior request. " +
-                            $"This request can never execute with the current rate limiter. Request weight: {weight}, RateLimit: {Limit}");
-                    }
+                    throw new Exception("Request limit reached without any prior request. " +
+                        $"This request can never execute with the current rate limiter. Request weight: {weight}, RateLimit: {Limit}");
                 }
 
                 // Determine the time to wait before this weight can be applied without going over the rate limit
-                return DetermineWaitTime(weight, allowedRateRatio);
+                return DetermineWaitTime(weight);
             }
 
             // Weight can fit without going over limit
@@ -102,7 +90,7 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
         {
             for (var i = 0; i < _entries.Count; i++)
             {
-                if (_entries[i].Timestamp <= time)
+                if (_entries[i].Timestamp < time)
                 {
                     var entry = _entries[i];
                     _entries.Remove(entry);
@@ -120,9 +108,9 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
         /// Determine the time to wait before the weight would fit
         /// </summary>
         /// <returns></returns>
-        private TimeSpan DetermineWaitTime(int requestWeight, double allowedRateRatio)
+        private TimeSpan DetermineWaitTime(int requestWeight)
         {
-            var weightToRemove = Math.Max(Current + requestWeight - Limit * allowedRateRatio, 0);
+            var weightToRemove = Math.Max(Current - (Limit - requestWeight), 0);
             var removedWeight = 0;
             for (var i = 0; i < _entries.Count; i++)
             {
@@ -130,7 +118,7 @@ namespace CryptoExchange.Net.RateLimiting.Trackers
                 removedWeight += entry.Weight;
                 if (removedWeight >= weightToRemove)
                 {
-                    var result = entry.Timestamp + TimePeriod + _safetyMargin - DateTime.UtcNow;
+                    var result = entry.Timestamp + TimePeriod + _slidingWindowBuffer - DateTime.UtcNow;
                     if (result < TimeSpan.Zero)
                         return TimeSpan.Zero;
                     return result;

CryptoExchange.Net/RateLimiting/Trackers/WindowTrackerHelpers.cs

@@ -1,20 +0,0 @@
-using System;
-
-namespace CryptoExchange.Net.RateLimiting.Trackers
-{
-    internal static class WindowTrackerHelpers
-    {
-        private static readonly TimeSpan _minimumSafetyMargin = TimeSpan.FromMilliseconds(10);
-        private static readonly TimeSpan _maximumSafetyMargin = TimeSpan.FromMilliseconds(250);
-
-        public static TimeSpan GetDefaultSafetyMargin(TimeSpan period)
-        {
-            var margin = TimeSpan.FromTicks(period.Ticks / 20);
-            if (margin < _minimumSafetyMargin)
-                return _minimumSafetyMargin;
-            if (margin > _maximumSafetyMargin)
-                return _maximumSafetyMargin;
-            return margin;
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Assets.cs

@@ -1,27 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    /// <summary>
-    /// Catalog of Shared API capability references.
-    /// </summary>
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Asset capabilities.
-        /// </summary>
-        public static class Assets
-        {
-            /// <summary>
-            /// Get asset capability.
-            /// </summary>
-            public static SharedRestCapability<IGetAsset, IGetAssetRest> GetAsset { get; } = new();
-            /// <summary>
-            /// Get all assets capability.
-            /// </summary>
-            public static SharedRestCapability<IGetAllAssets, IGetAllAssetsRest> GetAllAssets { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Balances.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Balance capabilities.
-        /// </summary>
-        public static class Balances
-        {
-            /// <summary>
-            /// Get balances capability.
-            /// </summary>
-            public static SharedRestCapability<IGetBalances, IGetBalancesRest> GetBalances { get; } = new();
-            /// <summary>
-            /// Subscribe to balance updates capability.
-            /// </summary>
-            public static SharedCapabilityReference<ISubscribeBalancesSocket> SubscribeBalances { get; } = new();
-        }
-
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Deposits.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Deposit capabilities.
-        /// </summary>
-        public static class Deposits
-        {
-            /// <summary>
-            /// Get deposit addresses capability.
-            /// </summary>
-            public static SharedRestCapability<IGetDepositAddresses, IGetDepositAddressesRest> GetDepositAddresses { get; } = new();
-            /// <summary>
-            /// Get deposit history capability.
-            /// </summary>
-            public static SharedRestCapability<IGetDepositHistory, IGetDepositHistoryRest> GetDepositHistory { get; } = new();
-        }
-
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Fees.cs

@@ -1,21 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Fee capabilities.
-        /// </summary>
-        public static class Fees
-        {
-            /// <summary>
-            /// Get fees capability.
-            /// </summary>
-            public static SharedRestCapability<IGetFees, IGetFeesRest> GetFees { get; } = new();
-        }
-
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Funding.cs

@@ -1,32 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Funding capabilities.
-        /// </summary>
-        public static class Funding
-        {
-            /// <summary>
-            /// Get current funding information capability.
-            /// </summary>
-            public static SharedRestCapability<IGetFundingInfo, IGetFundingInfoRest> GetFundingInfo { get; } = new();
-            /// <summary>
-            /// Get funding rate history capability.
-            /// </summary>
-            public static SharedRestCapability<IGetFundingRateHistory, IGetFundingRateHistoryRest> GetFundingRateHistory { get; } = new();
-            /// <summary>
-            /// Get user funding history capability.
-            /// </summary>
-            public static SharedRestCapability<IGetUserFundingHistory, IGetUserFundingHistoryRest> GetUserFundingHistory { get; } = new();
-            /// <summary>
-            /// Subscribe to funding info updates capability.
-            /// </summary>
-            public static SharedCapabilityReference<ISubscribeFundingInfoSocket> SubscribeFundingInfo { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.IndexPrices.cs

@@ -1,28 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Index price capabilities.
-        /// </summary>
-        public static class IndexPrices
-        {
-            /// <summary>
-            /// Get an index price capability.
-            /// </summary>
-            public static SharedRestCapability<IGetIndexPrice, IGetIndexPriceRest> GetIndexPrice { get; } = new();
-            /// <summary>
-            /// Get all index prices capability.
-            /// </summary>
-            public static SharedRestCapability<IGetAllIndexPrices, IGetAllIndexPricesRest> GetAllIndexPrices { get; } = new();
-            /// <summary>
-            /// Subscribe to index price updates capability.
-            /// </summary>
-            public static SharedCapabilityReference<ISubscribeIndexPriceSocket> SubscribeIndexPrice { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Klines.cs

@@ -1,36 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Kline capabilities.
-        /// </summary>
-        public static class Klines
-        {
-            /// <summary>
-            /// Get klines capability.
-            /// </summary>
-            public static SharedRestCapability<IGetKlines, IGetKlinesRest> GetKlines { get; } = new();
-
-            /// <summary>
-            /// Get mark price klines capability.
-            /// </summary>
-            public static SharedRestCapability<IGetMarkPriceKlines, IGetMarkPriceKlinesRest> GetMarkPriceKlines { get; } = new();
-
-            /// <summary>
-            /// Get index price klines capability.
-            /// </summary>
-            public static SharedRestCapability<IGetIndexPriceKlines, IGetIndexPriceKlinesRest> GetIndexPriceKlines { get; } = new();
-
-            /// <summary>
-            /// Subscribe to kline updates capability.
-            /// </summary>
-            public static SharedCapabilityReference<ISubscribeKlinesSocket> SubscribeKlines { get; } = new();
-        }
-
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Ledger.cs

@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Ledger capabilities.
-        /// </summary>
-        public static class Ledger
-        {
-            /// <summary>
-            /// Get ledger entries capability.
-            /// </summary>
-            public static SharedRestCapability<IGetLedger, IGetLedgerRest> GetLedger { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Leverage.cs

@@ -1,30 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Leverage capabilities.
-        /// </summary>
-        public static class Leverage
-        {
-            /// <summary>
-            /// Get leverage capability.
-            /// </summary>
-            public static SharedRestCapability<IGetLeverage, IGetLeverageRest> GetLeverage { get; } = new();
-
-            /// <summary>
-            /// Set leverage capability.
-            /// </summary>
-            public static SharedRestCapability<ISetLeverage, ISetLeverageRest> SetLeverage { get; } = new();
-
-            /// <summary>
-            /// Get leverage tiers capability.
-            /// </summary>
-            public static SharedRestCapability<IGetLeverageTiers, IGetLeverageTiersRest> GetLeverageTiers { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.MarkPrices.cs

@@ -1,30 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Mark price capabilities.
-        /// </summary>
-        public static class MarkPrices
-        {
-            /// <summary>
-            /// Get a mark price capability.
-            /// </summary>
-            public static SharedRestCapability<IGetMarkPrice, IGetMarkPriceRest> GetMarkPrice { get; } = new();
-
-            /// <summary>
-            /// Get all mark prices capability.
-            /// </summary>
-            public static SharedRestCapability<IGetAllMarkPrices, IGetAllMarkPricesRest> GetAllMarkPrices { get; } = new();
-
-            /// <summary>
-            /// Subscribe to mark price updates capability.
-            /// </summary>
-            public static SharedCapabilityReference<ISubscribeMarkPriceSocket> SubscribeMarkPrice { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.OpenInterest.cs

@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Open interest capabilities.
-        /// </summary>
-        public static class OpenInterest
-        {
-            /// <summary>
-            /// Get open interest capability.
-            /// </summary>
-            public static SharedRestCapability<IGetOpenInterest, IGetOpenInterestRest> GetOpenInterest { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.OrderBooks.cs

@@ -1,35 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Order book capabilities.
-        /// </summary>
-        public static class OrderBooks
-        {
-            /// <summary>
-            /// Get an order book capability.
-            /// </summary>
-            public static SharedRestCapability<IGetOrderBook, IGetOrderBookRest> GetOrderBook { get; } = new();
-
-            /// <summary>
-            /// Get a book ticker capability.
-            /// </summary>
-            public static SharedRestCapability<IGetBookTicker, IGetBookTickerRest> GetBookTicker { get; } = new();
-
-            /// <summary>
-            /// Subscribe to order book updates capability.
-            /// </summary>
-            public static SharedCapabilityReference<ISubscribeOrderBookSocket> SubscribeOrderBook { get; } = new();
-
-            /// <summary>
-            /// Subscribe to incremental order book updates capability.
-            /// </summary>
-            public static SharedCapabilityReference<ISubscribeIncrementalOrderBookSocket> SubscribeIncrementalOrderBook { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Orders.cs

@@ -1,157 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Order capabilities.
-        /// </summary>
-        public static class Orders
-        {
-            /// <summary>
-            /// Spot order capabilities.
-            /// </summary>
-            public static class Spot
-            {
-                /// <summary>
-                /// Place a spot order capability.
-                /// </summary>
-                public static SharedRestSocketCapability<IPlaceSpotOrder, IPlaceSpotOrderRest, IPlaceSpotOrderSocket> PlaceOrder { get; } = new();
-
-                /// <summary>
-                /// Place multiple spot orders capability.
-                /// </summary>
-                public static SharedRestSocketCapability<IPlaceMultipleSpotOrders, IPlaceMultipleSpotOrdersRest, IPlaceMultipleSpotOrdersSocket> PlaceMultipleOrders { get; } = new();
-
-                /// <summary>
-                /// Edit a spot order capability.
-                /// </summary>
-                public static SharedRestSocketCapability<IEditSpotOrder, IEditSpotOrderRest, IEditSpotOrderSocket> EditOrder { get; } = new();
-
-                /// <summary>
-                /// Edit a spot order by client order id capability.
-                /// </summary>
-                public static SharedRestSocketCapability<IEditSpotOrderByClientOrderId, IEditSpotOrderByClientOrderIdRest, IEditSpotOrderByClientOrderIdSocket> EditOrderByClientOrderId { get; } = new();
-
-                /// <summary>
-                /// Cancel a spot order capability.
-                /// </summary>
-                public static SharedRestSocketCapability<ICancelSpotOrder, ICancelSpotOrderRest, ICancelSpotOrderSocket> CancelOrder { get; } = new();
-
-                /// <summary>
-                /// Cancel a spot order by client order id capability.
-                /// </summary>
-                public static SharedRestSocketCapability<ICancelSpotOrderByClientOrderId, ICancelSpotOrderByClientOrderIdRest, ICancelSpotOrderByClientOrderIdSocket> CancelOrderByClientOrderId { get; } = new();
-
-                /// <summary>
-                /// Cancel all spot orders capability.
-                /// </summary>
-                public static SharedRestSocketCapability<ICancelAllSpotOrders, ICancelAllSpotOrdersRest, ICancelAllSpotOrdersSocket> CancelAllOrders { get; } = new();
-
-                /// <summary>
-                /// Cancel all spot orders for a symbol capability.
-                /// </summary>
-                public static SharedRestSocketCapability<ICancelAllSpotSymbolOrders, ICancelAllSpotSymbolOrdersRest, ICancelAllSpotSymbolOrdersSocket> CancelAllSymbolOrders { get; } = new();
-
-                /// <summary>
-                /// Get a spot order capability.
-                /// </summary>
-                public static SharedRestCapability<IGetSpotOrder, IGetSpotOrderRest> GetOrder { get; } = new();
-
-                /// <summary>
-                /// Get a spot order by client order id capability.
-                /// </summary>
-                public static SharedRestCapability<IGetSpotOrderByClientOrderId, IGetSpotOrderByClientOrderIdRest> GetOrderByClientOrderId { get; } = new();
-
-                /// <summary>
-                /// Get open spot orders capability.
-                /// </summary>
-                public static SharedRestCapability<IGetOpenSpotOrders, IGetOpenSpotOrdersRest> GetOpenOrders { get; } = new();
-
-                /// <summary>
-                /// Get closed spot orders capability.
-                /// </summary>
-                public static SharedRestCapability<IGetClosedSpotOrders, IGetClosedSpotOrdersRest> GetClosedOrders { get; } = new();
-
-                /// <summary>
-                /// Subscribe to spot order updates capability.
-                /// </summary>
-                public static SharedCapabilityReference<ISubscribeSpotOrdersSocket> SubscribeOrders { get; } = new();
-            }
-
-            /// <summary>
-            /// Futures order capabilities.
-            /// </summary>
-            public static class Futures
-            {
-                /// <summary>
-                /// Place a futures order capability.
-                /// </summary>
-                public static SharedRestSocketCapability<IPlaceFuturesOrder, IPlaceFuturesOrderRest, IPlaceFuturesOrderSocket> PlaceOrder { get; } = new();
-
-                /// <summary>
-                /// Place multiple futures orders capability.
-                /// </summary>
-                public static SharedRestSocketCapability<IPlaceMultipleFuturesOrders, IPlaceMultipleFuturesOrdersRest, IPlaceMultipleFuturesOrdersSocket> PlaceMultipleOrders { get; } = new();
-
-                /// <summary>
-                /// Edit a futures order capability.
-                /// </summary>
-                public static SharedRestSocketCapability<IEditFuturesOrder, IEditFuturesOrderRest, IEditFuturesOrderSocket> EditOrder { get; } = new();
-
-                /// <summary>
-                /// Edit a futures order by client order id capability.
-                /// </summary>
-                public static SharedRestSocketCapability<IEditFuturesOrderByClientOrderId, IEditFuturesOrderByClientOrderIdRest, IEditFuturesOrderByClientOrderIdSocket> EditOrderByClientOrderId { get; } = new();
-
-                /// <summary>
-                /// Cancel a futures order capability.
-                /// </summary>
-                public static SharedRestSocketCapability<ICancelFuturesOrder, ICancelFuturesOrderRest, ICancelFuturesOrderSocket> CancelOrder { get; } = new();
-
-                /// <summary>
-                /// Cancel a futures order by client order id capability.
-                /// </summary>
-                public static SharedRestSocketCapability<ICancelFuturesOrderByClientOrderId, ICancelFuturesOrderByClientOrderIdRest, ICancelFuturesOrderByClientOrderIdSocket> CancelOrderByClientOrderId { get; } = new();
-
-                /// <summary>
-                /// Cancel all futures orders capability.
-                /// </summary>
-                public static SharedRestSocketCapability<ICancelAllFuturesOrders, ICancelAllFuturesOrdersRest, ICancelAllFuturesOrdersSocket> CancelAllOrders { get; } = new();
-
-                /// <summary>
-                /// Cancel all futures orders for a symbol capability.
-                /// </summary>
-                public static SharedRestSocketCapability<ICancelAllFuturesSymbolOrders, ICancelAllFuturesSymbolOrdersRest, ICancelAllFuturesSymbolOrdersSocket> CancelAllSymbolOrders { get; } = new();
-
-                /// <summary>
-                /// Get a futures order capability.
-                /// </summary>
-                public static SharedRestCapability<IGetFuturesOrder, IGetFuturesOrderRest> GetOrder { get; } = new();
-
-                /// <summary>
-                /// Get a futures order by client order id capability.
-                /// </summary>
-                public static SharedRestCapability<IGetFuturesOrderByClientOrderId, IGetFuturesOrderByClientOrderIdRest> GetOrderByClientOrderId { get; } = new();
-
-                /// <summary>
-                /// Get open futures orders capability.
-                /// </summary>
-                public static SharedRestCapability<IGetOpenFuturesOrders, IGetOpenFuturesOrdersRest> GetOpenOrders { get; } = new();
-
-                /// <summary>
-                /// Get closed futures orders capability.
-                /// </summary>
-                public static SharedRestCapability<IGetClosedFuturesOrders, IGetClosedFuturesOrdersRest> GetClosedOrders { get; } = new();
-
-                /// <summary>
-                /// Subscribe to futures order updates capability.
-                /// </summary>
-                public static SharedCapabilityReference<ISubscribeFuturesOrdersSocket> SubscribeOrders { get; } = new();
-            }
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.PositionMode.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Position mode capabilities.
-        /// </summary>
-        public static class PositionMode
-        {
-            /// <summary>
-            /// Get position mode capability.
-            /// </summary>
-            public static SharedRestCapability<IGetPositionMode, IGetPositionModeRest> GetPositionMode { get; } = new();
-
-            /// <summary>
-            /// Set position mode capability.
-            /// </summary>
-            public static SharedRestCapability<ISetPositionMode, ISetPositionModeRest> SetPositionMode { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Positions.cs

@@ -1,35 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Position capabilities.
-        /// </summary>
-        public static class Positions
-        {
-            /// <summary>
-            /// Get positions capability.
-            /// </summary>
-            public static SharedRestCapability<IGetPositions, IGetPositionsRest> GetPositions { get; } = new();
-
-            /// <summary>
-            /// Get position history capability.
-            /// </summary>
-            public static SharedRestCapability<IGetPositionHistory, IGetPositionHistoryRest> GetPositionHistory { get; } = new();
-
-            /// <summary>
-            /// Close a full position capability.
-            /// </summary>
-            public static SharedRestCapability<ICloseFullPosition, ICloseFullPositionRest> CloseFullPosition { get; } = new();
-
-            /// <summary>
-            /// Subscribe to position updates capability.
-            /// </summary>
-            public static SharedCapabilityReference<ISubscribePositionsSocket> SubscribePositions { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Symbols.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Symbol capabilities.
-        /// </summary>
-        public static class Symbols
-        {
-            /// <summary>
-            /// Get spot symbols capability.
-            /// </summary>
-            public static SharedRestCapability<IGetSpotSymbols, IGetSpotSymbolsRest> GetSpotSymbols { get; } = new();
-
-            /// <summary>
-            /// Get futures symbols capability.
-            /// </summary>
-            public static SharedRestCapability<IGetFuturesSymbols, IGetFuturesSymbolsRest> GetFuturesSymbols { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Tickers.cs

@@ -1,40 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Ticker capabilities.
-        /// </summary>
-        public static class Tickers
-        {
-            /// <summary>
-            /// Get a ticker capability.
-            /// </summary>
-            public static SharedRestCapability<IGetTicker, IGetTickerRest> GetTicker { get; } = new();
-
-            /// <summary>
-            /// Get all tickers capability.
-            /// </summary>
-            public static SharedRestCapability<IGetAllTickers, IGetAllTickersRest> GetAllTickers { get; } = new();
-
-            /// <summary>
-            /// Subscribe to ticker updates capability.
-            /// </summary>
-            public static SharedCapabilityReference<ISubscribeTickerSocket> SubscribeTicker { get; } = new();
-
-            /// <summary>
-            /// Subscribe to all ticker updates capability.
-            /// </summary>
-            public static SharedCapabilityReference<ISubscribeAllTickersSocket> SubscribeAllTickers { get; } = new();
-
-            /// <summary>
-            /// Subscribe to book ticker updates capability.
-            /// </summary>
-            public static SharedCapabilityReference<ISubscribeBookTickerSocket> SubscribeBookTicker { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.TpSl.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Take profit and stop loss capabilities.
-        /// </summary>
-        public static class TpSl
-        {
-            /// <summary>
-            /// Set futures take profit or stop loss capability.
-            /// </summary>
-            public static SharedRestCapability<ISetFuturesTpSl, ISetFuturesTpSlRest> SetFuturesTpSl { get; } = new();
-
-            /// <summary>
-            /// Cancel futures take profit or stop loss capability.
-            /// </summary>
-            public static SharedRestCapability<ICancelFuturesTpSl, ICancelFuturesTpSlRest> CancelFuturesTpSl { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Trades.cs

@@ -1,30 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Public trade capabilities.
-        /// </summary>
-        public static class Trades
-        {
-            /// <summary>
-            /// Get recent trades capability.
-            /// </summary>
-            public static SharedRestCapability<IGetRecentTrades, IGetRecentTradesRest> GetRecentTrades { get; } = new();
-
-            /// <summary>
-            /// Get trade history capability.
-            /// </summary>
-            public static SharedRestCapability<IGetTradeHistory, IGetTradeHistoryRest> GetTradeHistory { get; } = new();
-
-            /// <summary>
-            /// Subscribe to trade updates capability.
-            /// </summary>
-            public static SharedCapabilityReference<ISubscribeTradesSocket> SubscribeTrades { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Transfers.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Transfer capabilities.
-        /// </summary>
-        public static class Transfers
-        {
-            /// <summary>
-            /// Transfer assets capability.
-            /// </summary>
-            public static SharedRestCapability<ITransfer, ITransferRest> Transfer { get; } = new();
-
-            /// <summary>
-            /// Get transfer history capability.
-            /// </summary>
-            public static SharedRestCapability<IGetTransferHistory, IGetTransferHistoryRest> GetTransferHistory { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.TriggerOrders.cs

@@ -1,57 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Trigger order capabilities.
-        /// </summary>
-        public static class TriggerOrders
-        {
-            /// <summary>
-            /// Spot trigger order capabilities.
-            /// </summary>
-            public static class Spot
-            {
-                /// <summary>
-                /// Place a spot trigger order capability.
-                /// </summary>
-                public static SharedRestCapability<IPlaceSpotTriggerOrder, IPlaceSpotTriggerOrderRest> PlaceOrder { get; } = new();
-
-                /// <summary>
-                /// Get a spot trigger order capability.
-                /// </summary>
-                public static SharedRestCapability<IGetSpotTriggerOrder, IGetSpotTriggerOrderRest> GetOrder { get; } = new();
-
-                /// <summary>
-                /// Cancel a spot trigger order capability.
-                /// </summary>
-                public static SharedRestCapability<ICancelSpotTriggerOrder, ICancelSpotTriggerOrderRest> CancelOrder { get; } = new();
-            }
-
-            /// <summary>
-            /// Futures trigger order capabilities.
-            /// </summary>
-            public static class Futures
-            {
-                /// <summary>
-                /// Place a futures trigger order capability.
-                /// </summary>
-                public static SharedRestCapability<IPlaceFuturesTriggerOrder, IPlaceFuturesTriggerOrderRest> PlaceOrder { get; } = new();
-
-                /// <summary>
-                /// Get a futures trigger order capability.
-                /// </summary>
-                public static SharedRestCapability<IGetFuturesTriggerOrder, IGetFuturesTriggerOrderRest> GetOrder { get; } = new();
-
-                /// <summary>
-                /// Cancel a futures trigger order capability.
-                /// </summary>
-                public static SharedRestCapability<ICancelFuturesTriggerOrder, ICancelFuturesTriggerOrderRest> CancelOrder { get; } = new();
-            }
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.UserTrades.cs

@@ -1,40 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// User trade capabilities.
-        /// </summary>
-        public static class UserTrades
-        {
-            /// <summary>
-            /// Get trades for a spot order capability.
-            /// </summary>
-            public static SharedRestCapability<IGetSpotOrderTrades, IGetSpotOrderTradesRest> GetSpotOrderTrades { get; } = new();
-
-            /// <summary>
-            /// Get spot user trade history capability.
-            /// </summary>
-            public static SharedRestCapability<IGetSpotUserTradeHistory, IGetSpotUserTradeHistoryRest> GetSpotTradeHistory { get; } = new();
-
-            /// <summary>
-            /// Get trades for a futures order capability.
-            /// </summary>
-            public static SharedRestCapability<IGetFuturesOrderTrades, IGetFuturesOrderTradesRest> GetFuturesOrderTrades { get; } = new();
-
-            /// <summary>
-            /// Get futures user trade history capability.
-            /// </summary>
-            public static SharedRestCapability<IGetFuturesUserTradeHistory, IGetFuturesUserTradeHistoryRest> GetFuturesTradeHistory { get; } = new();
-
-            /// <summary>
-            /// Subscribe to user trade updates capability.
-            /// </summary>
-            public static SharedCapabilityReference<ISubscribeUserTradesSocket> SubscribeUserTrades { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilities.Withdrawals.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    public static partial class SharedCapabilities
-    {
-        /// <summary>
-        /// Withdrawal capabilities.
-        /// </summary>
-        public static class Withdrawals
-        {
-            /// <summary>
-            /// Withdraw assets capability.
-            /// </summary>
-            public static SharedRestCapability<IWithdraw, IWithdrawRest> Withdraw { get; } = new();
-
-            /// <summary>
-            /// Get withdrawal history capability.
-            /// </summary>
-            public static SharedRestCapability<IGetWithdrawalHistory, IGetWithdrawalHistoryRest> GetWithdrawalHistory { get; } = new();
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilityReference.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    /// <summary>
-    /// Strongly typed reference to a Shared API capability.
-    /// </summary>
-    public class SharedCapabilityReference<T>
-        where T : ISharedApiCapability
-    {
-        /// <summary>
-        /// Capability interface type.
-        /// </summary>
-        public Type CapabilityType => typeof(T);
-
-        internal SharedCapabilityReference()
-        {
-        }
-
-        /// <inheritdoc />
-        public override string ToString() => typeof(T).Name;
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedCapabilityResolution.cs

@@ -1,41 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    /// <summary>
-    /// Capability lookup result
-    /// </summary>
-    /// <typeparam name="T">Capability type</typeparam>
-    public class SharedCapabilityResolution<T>
-        where T : ISharedApiCapability
-    {
-        /// <summary>
-        /// The exchange name
-        /// </summary>
-        public string Exchange => Capability.Exchange;
-
-        /// <summary>
-        /// The transport type
-        /// </summary>
-        public SharedTransport Transport => Capability.Transport;
-
-        /// <summary>
-        /// The capability
-        /// </summary>
-        public T Capability { get; }
-        /// <summary>
-        /// The capability options
-        /// </summary>
-        public CapabilityOptions Options { get; }
-
-        internal SharedCapabilityResolution(
-            T capability,
-            CapabilityOptions options)
-        {
-            Capability = capability;
-            Options = options;
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedRestCapability.cs

@@ -1,29 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    /// <summary>
-    /// References for a capability available through REST.
-    /// </summary>
-    public class SharedRestCapability<TCapability, TRest>
-        : SharedCapabilityReference<TCapability>
-        where TCapability : ISharedApiCapability
-        where TRest : TCapability, ISharedRest
-    {
-        /// <summary>
-        /// Transport-agnostic capability.
-        /// </summary>
-        public SharedCapabilityReference<TCapability> Any { get; } = new();
-
-        /// <summary>
-        /// REST capability.
-        /// </summary>
-        public SharedCapabilityReference<TRest> Rest { get; } = new();
-
-        internal SharedRestCapability()
-        {
-        }
-    }
-}

CryptoExchange.Net/SharedApis/CapabilityReferences/SharedRestSocketCapability.cs

@@ -1,30 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    /// <summary>
-    /// References for a capability available through REST and WebSocket.
-    /// </summary>
-    public class SharedRestSocketCapability<TCapability, TRest, TSocket>
-        : SharedCapabilityReference<TCapability>
-        where TCapability : ISharedApiCapability
-        where TRest : TCapability, ISharedRest
-        where TSocket : TCapability, ISharedSocket
-    {
-        /// <summary>
-        /// REST capability.
-        /// </summary>
-        public SharedCapabilityReference<TRest> Rest { get; } = new();
-
-        /// <summary>
-        /// WebSocket capability.
-        /// </summary>
-        public SharedCapabilityReference<TSocket> Socket { get; } = new();
-
-        internal SharedRestSocketCapability()
-        {
-        }
-    }
-}

CryptoExchange.Net/SharedApis/Enums/SharedLedgerEntryType.cs

@@ -1,42 +0,0 @@
-namespace CryptoExchange.Net.SharedApis
-{
-    /// <summary>
-    /// Ledger entry type
-    /// </summary>
-    public enum SharedLedgerEntryType
-    {
-        /// <summary>
-        /// Trade execution
-        /// </summary>
-        Trade,
-        /// <summary>
-        /// Withdrawal
-        /// </summary>
-        Withdrawal,
-        /// <summary>
-        /// Deposit
-        /// </summary>
-        Deposit,
-        /// <summary>
-        /// Transfer
-        /// </summary>
-        Transfer,
-        /// <summary>
-        /// Fee payment
-        /// </summary>
-        Fee,
-        /// <summary>
-        /// Funding fee payment
-        /// </summary>
-        FundingFee,
-        /// <summary>
-        /// Rebate
-        /// </summary>
-        Rebate,
-
-        /// <summary>
-        /// Other or unknown
-        /// </summary>
-        Unknown
-    }
-}

CryptoExchange.Net/SharedApis/Enums/SharedTransport.cs

@@ -1,21 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CryptoExchange.Net.SharedApis
-{
-    /// <summary>
-    /// The type of transport used for the shared API
-    /// </summary>
-    public enum SharedTransport
-    {
-        /// <summary>
-        /// REST transport
-        /// </summary>
-        Rest,
-        /// <summary>
-        /// WebSocket transport
-        /// </summary>
-        Socket
-    }
-}

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

@@ -14,7 +14,7 @@ namespace CryptoExchange.Net.SharedApis
         /// Use <see cref="CapabilityOptions.RequiredExchangeParameters"/> and <see cref="CapabilityOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
         /// Exchange specific parameters can be added to the request via the `ExchangeParameters` property of the request object.
         /// </summary>
-        GetTickerOptions GetFuturesTickerOptions { get; }
+        GetFuturesTickerOptions GetFuturesTickerOptions { get; }
         /// <summary>
         /// Get ticker info for a specific futures symbol, see <see cref="GetFuturesTickerOptions"/> for request options and exchange specific required/optional parameters. <br />
         /// </summary>
@@ -27,7 +27,7 @@ namespace CryptoExchange.Net.SharedApis
         /// Use <see cref="CapabilityOptions.RequiredExchangeParameters"/> and <see cref="CapabilityOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
         /// Exchange specific parameters can be added to the request via the `ExchangeParameters` property of the request object.
         /// </summary>
-        GetAllTickersOptions GetFuturesTickersOptions { get; }
+        GetAllFuturesTickersOptions GetFuturesTickersOptions { get; }
         /// <summary>
         /// Get ticker info for all futures symbols, see <see cref="GetFuturesTickersOptions"/> for request options and exchange specific required/optional parameters. <br />
         /// </summary>

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Rest/Spot/ISpotTickerRestClient.cs

@@ -14,7 +14,7 @@ namespace CryptoExchange.Net.SharedApis
         /// Use <see cref="CapabilityOptions.RequiredExchangeParameters"/> and <see cref="CapabilityOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
         /// Exchange specific parameters can be added to the request via the `ExchangeParameters` property of the request object.
         /// </summary>
-        GetTickerOptions GetSpotTickerOptions { get; }
+        GetSpotTickerOptions GetSpotTickerOptions { get; }
         /// <summary>
         /// Get ticker for a specific spot symbol, see <see cref="GetSpotTickerOptions"/> for request options and exchange specific required/optional parameters. <br />
         /// </summary>
@@ -26,7 +26,7 @@ namespace CryptoExchange.Net.SharedApis
         /// Use <see cref="CapabilityOptions.RequiredExchangeParameters"/> and <see cref="CapabilityOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
         /// Exchange specific parameters can be added to the request via the `ExchangeParameters` property of the request object.
         /// </summary>
-        GetAllTickersOptions GetSpotTickersOptions { get; }
+        GetAllSpotTickersOptions GetSpotTickersOptions { get; }
         /// <summary>
         /// Get tickers for all spot symbols, see <see cref="GetSpotTickersOptions"/> for request options and exchange specific required/optional parameters. <br />
         /// </summary>