wip

CryptoExchange.Net.UnitTests/RequestCoalescerTests.cs

@@ -0,0 +1,281 @@
+using CryptoExchange.Net.Objects;
+using Microsoft.Extensions.Logging.Abstractions;
+using NUnit.Framework;
+using System;
+using System.Collections;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.UnitTests
+{
+    [TestFixture]
+    public class RequestCoalescerTests
+    {
+        private static readonly TimeSpan _testTimeout = TimeSpan.FromSeconds(5);
+
+        [Test]
+        public async Task ExecuteAsync_WithIdenticalRequests_ShouldExecuteRequestOnce()
+        {
+            var coalescer = CreateCoalescer();
+            var key = CreateKey();
+            var requestCompletion = CreateCompletionSource<string>();
+            var requestStarted = CreateCompletionSource<bool>();
+            var requestCount = 0;
+
+            async Task<string> ExecuteRequest(CancellationToken cancellationToken)
+            {
+                Interlocked.Increment(ref requestCount);
+                requestStarted.TrySetResult(true);
+                return await requestCompletion.Task;
+            }
+
+            var first = coalescer.ExecuteAsync(key, ExecuteRequest, () => "canceled", CancellationToken.None);
+            await requestStarted.Task.WaitAsync(_testTimeout);
+            var second = coalescer.ExecuteAsync(key, ExecuteRequest, () => "canceled", CancellationToken.None);
+
+            Assert.That(requestCount, Is.EqualTo(1));
+
+            requestCompletion.SetResult("result");
+
+            Assert.That(await first.WaitAsync(_testTimeout), Is.EqualTo("result"));
+            Assert.That(await second.WaitAsync(_testTimeout), Is.EqualTo("result"));
+            Assert.That(requestCount, Is.EqualTo(1));
+        }
+
+        [Test]
+        public async Task ExecuteAsync_WithDifferentKeys_ShouldExecuteEachRequest()
+        {
+            var coalescer = CreateCoalescer();
+            var firstCompletion = CreateCompletionSource<string>();
+            var secondCompletion = CreateCompletionSource<string>();
+            var firstStarted = CreateCompletionSource<bool>();
+            var secondStarted = CreateCompletionSource<bool>();
+            var requestCount = 0;
+
+            var first = coalescer.ExecuteAsync(
+                CreateKey(parameters: "symbol=ETH"),
+                async cancellationToken =>
+                {
+                    Interlocked.Increment(ref requestCount);
+                    firstStarted.TrySetResult(true);
+                    return await firstCompletion.Task;
+                },
+                () => "canceled",
+                CancellationToken.None);
+
+            var second = coalescer.ExecuteAsync(
+                CreateKey(parameters: "symbol=BTC"),
+                async cancellationToken =>
+                {
+                    Interlocked.Increment(ref requestCount);
+                    secondStarted.TrySetResult(true);
+                    return await secondCompletion.Task;
+                },
+                () => "canceled",
+                CancellationToken.None);
+
+            await Task.WhenAll(firstStarted.Task, secondStarted.Task).WaitAsync(_testTimeout);
+            Assert.That(requestCount, Is.EqualTo(2));
+
+            firstCompletion.SetResult("first");
+            secondCompletion.SetResult("second");
+
+            Assert.That(await first.WaitAsync(_testTimeout), Is.EqualTo("first"));
+            Assert.That(await second.WaitAsync(_testTimeout), Is.EqualTo("second"));
+        }
+
+        [Test]
+        public async Task ExecuteAsync_WhenOneListenerCancels_ShouldKeepSharedRequestRunning()
+        {
+            var coalescer = CreateCoalescer();
+            var requestCompletion = CreateCompletionSource<string>();
+            var requestStarted = CreateCompletionSource<CancellationToken>();
+            var requestCount = 0;
+            using var firstCancellationSource = new CancellationTokenSource();
+
+            async Task<string> ExecuteRequest(CancellationToken cancellationToken)
+            {
+                Interlocked.Increment(ref requestCount);
+                requestStarted.TrySetResult(cancellationToken);
+                return await requestCompletion.Task;
+            }
+
+            var first = coalescer.ExecuteAsync(CreateKey(), ExecuteRequest, () => "canceled", firstCancellationSource.Token);
+            var requestCancellationToken = await requestStarted.Task.WaitAsync(_testTimeout);
+            var second = coalescer.ExecuteAsync(CreateKey(), ExecuteRequest, () => "canceled", CancellationToken.None);
+
+            firstCancellationSource.Cancel();
+
+            Assert.That(await first.WaitAsync(_testTimeout), Is.EqualTo("canceled"));
+            Assert.That(requestCancellationToken.IsCancellationRequested, Is.False);
+            Assert.That(requestCount, Is.EqualTo(1));
+
+            requestCompletion.SetResult("result");
+
+            Assert.That(await second.WaitAsync(_testTimeout), Is.EqualTo("result"));
+        }
+
+        [Test]
+        public async Task ExecuteAsync_WhenAllListenersCancel_ShouldCancelSharedRequest()
+        {
+            var coalescer = CreateCoalescer();
+            var requestStarted = CreateCompletionSource<bool>();
+            var requestCanceled = CreateCompletionSource<bool>();
+            using var firstCancellationSource = new CancellationTokenSource();
+            using var secondCancellationSource = new CancellationTokenSource();
+
+            async Task<string> ExecuteRequest(CancellationToken cancellationToken)
+            {
+                using (cancellationToken.Register(() => requestCanceled.TrySetResult(true)))
+                {
+                    requestStarted.TrySetResult(true);
+                    await requestCanceled.Task;
+                    return "request canceled";
+                }
+            }
+
+            var first = coalescer.ExecuteAsync(CreateKey(), ExecuteRequest, () => "listener canceled", firstCancellationSource.Token);
+            await requestStarted.Task.WaitAsync(_testTimeout);
+            var second = coalescer.ExecuteAsync(CreateKey(), ExecuteRequest, () => "listener canceled", secondCancellationSource.Token);
+
+            firstCancellationSource.Cancel();
+            Assert.That(await first.WaitAsync(_testTimeout), Is.EqualTo("listener canceled"));
+            Assert.That(requestCanceled.Task.IsCompleted, Is.False);
+
+            secondCancellationSource.Cancel();
+
+            Assert.That(await second.WaitAsync(_testTimeout), Is.EqualTo("listener canceled"));
+            Assert.That(await requestCanceled.Task.WaitAsync(_testTimeout), Is.True);
+        }
+
+        [Test]
+        public async Task ExecuteAsync_WithAlreadyCanceledListener_ShouldNotStartRequest()
+        {
+            var coalescer = CreateCoalescer();
+            var requestCount = 0;
+            using var cancellationSource = new CancellationTokenSource();
+            cancellationSource.Cancel();
+
+            var result = await coalescer.ExecuteAsync(
+                CreateKey(),
+                cancellationToken =>
+                {
+                    Interlocked.Increment(ref requestCount);
+                    return Task.FromResult("result");
+                },
+                () => "canceled",
+                cancellationSource.Token);
+
+            Assert.That(result, Is.EqualTo("canceled"));
+            Assert.That(requestCount, Is.Zero);
+        }
+
+        [Test]
+        public async Task ExecuteAsync_AfterRequestCompletes_ShouldStartNewRequest()
+        {
+            var coalescer = CreateCoalescer();
+            var requestCount = 0;
+
+            Task<int> ExecuteRequest(CancellationToken cancellationToken)
+                => Task.FromResult(Interlocked.Increment(ref requestCount));
+
+            var first = await coalescer.ExecuteAsync(CreateKey(typeof(int)), ExecuteRequest, () => -1, CancellationToken.None);
+            var second = await coalescer.ExecuteAsync(CreateKey(typeof(int)), ExecuteRequest, () => -1, CancellationToken.None);
+
+            Assert.That(first, Is.EqualTo(1));
+            Assert.That(second, Is.EqualTo(2));
+            Assert.That(requestCount, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void ExecuteAsync_AfterRequestFails_ShouldStartNewRequest()
+        {
+            var coalescer = CreateCoalescer();
+            var requestCount = 0;
+
+            Task<string> ExecuteRequest(CancellationToken cancellationToken)
+            {
+                if (Interlocked.Increment(ref requestCount) == 1)
+                    return Task.FromException<string>(new InvalidOperationException("Request failed"));
+
+                return Task.FromResult("result");
+            }
+
+            Assert.ThrowsAsync<InvalidOperationException>(async () =>
+                await coalescer.ExecuteAsync(CreateKey(), ExecuteRequest, () => "canceled", CancellationToken.None));
+
+            Assert.That(
+                coalescer.ExecuteAsync(CreateKey(), ExecuteRequest, () => "canceled", CancellationToken.None).GetAwaiter().GetResult(),
+                Is.EqualTo("result"));
+            Assert.That(requestCount, Is.EqualTo(2));
+        }
+
+        [Test]
+        public async Task ExecuteAsync_WhenAbandonedRequestCompletes_ShouldNotRemoveReplacementRequest()
+        {
+            var coalescer = CreateCoalescer();
+            var key = CreateKey();
+            var oldRequestCompletion = CreateCompletionSource<string>();
+            var oldRequestStarted = CreateCompletionSource<bool>();
+            var replacementCompletion = CreateCompletionSource<string>();
+            var replacementStarted = CreateCompletionSource<bool>();
+            var requestCount = 0;
+            using var cancellationSource = new CancellationTokenSource();
+
+            async Task<string> ExecuteOldRequest(CancellationToken cancellationToken)
+            {
+                Interlocked.Increment(ref requestCount);
+                oldRequestStarted.TrySetResult(true);
+                return await oldRequestCompletion.Task;
+            }
+
+            async Task<string> ExecuteReplacementRequest(CancellationToken cancellationToken)
+            {
+                Interlocked.Increment(ref requestCount);
+                replacementStarted.TrySetResult(true);
+                return await replacementCompletion.Task;
+            }
+
+            var abandonedListener = coalescer.ExecuteAsync(key, ExecuteOldRequest, () => "canceled", cancellationSource.Token);
+            await oldRequestStarted.Task.WaitAsync(_testTimeout);
+            var oldPhysicalRequest = GetPhysicalRequest(coalescer, key);
+
+            cancellationSource.Cancel();
+            Assert.That(await abandonedListener.WaitAsync(_testTimeout), Is.EqualTo("canceled"));
+
+            var replacementListener = coalescer.ExecuteAsync(key, ExecuteReplacementRequest, () => "canceled", CancellationToken.None);
+            await replacementStarted.Task.WaitAsync(_testTimeout);
+
+            oldRequestCompletion.SetResult("old result");
+            await oldPhysicalRequest.WaitAsync(_testTimeout);
+
+            var joinedReplacementListener = coalescer.ExecuteAsync(key, ExecuteReplacementRequest, () => "canceled", CancellationToken.None);
+            Assert.That(requestCount, Is.EqualTo(2));
+
+            replacementCompletion.SetResult("replacement result");
+
+            Assert.That(await replacementListener.WaitAsync(_testTimeout), Is.EqualTo("replacement result"));
+            Assert.That(await joinedReplacementListener.WaitAsync(_testTimeout), Is.EqualTo("replacement result"));
+            Assert.That(requestCount, Is.EqualTo(2));
+        }
+
+        private static RequestCoalescer CreateCoalescer()
+            => new RequestCoalescer(NullLogger.Instance);
+
+        private static RequestCoalescingKey CreateKey(Type? responseType = null, string? parameters = null)
+            => new RequestCoalescingKey("GET", "https://localhost/test", parameters, responseType ?? typeof(string));
+
+        private static TaskCompletionSource<T> CreateCompletionSource<T>()
+            => new TaskCompletionSource<T>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        private static Task GetPhysicalRequest(RequestCoalescer coalescer, RequestCoalescingKey key)
+        {
+            var requestsField = typeof(RequestCoalescer).GetField("_requests", BindingFlags.Instance | BindingFlags.NonPublic)!;
+            var requests = (IDictionary)requestsField.GetValue(coalescer)!;
+            var entry = requests[key]!;
+            var requestProperty = entry.GetType().GetProperty("Request")!;
+            return ((Lazy<Task<object>>)requestProperty.GetValue(entry)!).Value;
+        }
+    }
+}

CryptoExchange.Net/Clients/RestApiClient.cs

@@ -98,6 +98,10 @@ namespace CryptoExchange.Net.Clients
         /// Configured environment name
         /// </summary>
         public abstract string EnvironmentName { get; }
+        /// <summary>
+        /// Request coalescer
+        /// </summary>
+        protected RequestCoalescer RequestCoalescer { get; }
 
         /// <summary>
         /// ctor
@@ -123,6 +127,7 @@ namespace CryptoExchange.Net.Clients
         {
             TimeOffsetManager.RegisterRestApi(ClientName);
 
+            RequestCoalescer = new RequestCoalescer(_logger);
             RequestFactory.Configure(options, httpClient);
         }
 
@@ -177,8 +182,7 @@ namespace CryptoExchange.Net.Clients
         /// <param name="weight">Override the request weight for this request definition, for example when the weight depends on the parameters</param>
         /// <param name="weightSingleLimiter">Specify the weight to apply to the individual rate limit guard for this request</param>
         /// <param name="rateLimitKeySuffix">An additional optional suffix for the key selector. Can be used to make rate limiting work based on parameters.</param>
-        /// <returns></returns>
-        protected virtual async Task<HttpResult<T>> SendAsync<T>(
+        protected virtual Task<HttpResult<T>> SendAsync<T>(
             RequestDefinition definition,
             Parameters? uriParameters,
             Parameters? bodyParameters,
@@ -187,6 +191,61 @@ namespace CryptoExchange.Net.Clients
             int? weight = null,
             int? weightSingleLimiter = null,
             string? rateLimitKeySuffix = null)
+        {
+            if (!ShouldCoalesce(definition, additionalHeaders))
+            {
+                return SendCoreAsync<T>(
+                    definition,
+                    uriParameters,
+                    bodyParameters,
+                    cancellationToken,
+                    additionalHeaders,
+                    weight,
+                    weightSingleLimiter,
+                    rateLimitKeySuffix);
+            }
+
+            var key = GetRequestCoalescingKey<T>(
+                definition,
+                uriParameters);
+
+            return RequestCoalescer.ExecuteAsync(
+                key,
+                requestCancellationToken => SendCoreAsync<T>(
+                    definition,
+                    uriParameters,
+                    bodyParameters,
+                    requestCancellationToken,
+                    additionalHeaders,
+                    weight,
+                    weightSingleLimiter,
+                    rateLimitKeySuffix),
+                () => HttpResult.Fail<T>(
+                    Exchange,
+                    new CancellationRequestedError()),
+                cancellationToken);
+        }
+
+        /// <summary>
+        /// Send a request to the base address based on the request definition
+        /// </summary>
+        /// <typeparam name="T">Response type</typeparam>
+        /// <param name="definition">Request definition</param>
+        /// <param name="uriParameters">Request query parameters</param>
+        /// <param name="bodyParameters">Request body parameters</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <param name="additionalHeaders">Additional headers for this request</param>
+        /// <param name="weight">Override the request weight for this request definition, for example when the weight depends on the parameters</param>
+        /// <param name="weightSingleLimiter">Specify the weight to apply to the individual rate limit guard for this request</param>
+        /// <param name="rateLimitKeySuffix">An additional optional suffix for the key selector. Can be used to make rate limiting work based on parameters.</param>
+        protected virtual async Task<HttpResult<T>> SendCoreAsync<T>(RequestDefinition definition,
+            Parameters? uriParameters,
+            Parameters? bodyParameters,
+            CancellationToken cancellationToken,
+            Dictionary<string, string>? additionalHeaders = null,
+            int? weight = null,
+            int? weightSingleLimiter = null,
+            string? rateLimitKeySuffix = null)
         {
             var requestId = ExchangeHelpers.NextId();
             if (definition.Authenticated && GetAuthenticationProvider() == null)
@@ -688,7 +747,10 @@ namespace CryptoExchange.Net.Clients
                         stringData = stringSerializer.Serialize(parameters.BodyValue);
                 }
                 else
+                {
                     stringData = stringSerializer.Serialize(parameters);
+                }
+
                 request.SetContent(stringData, RequestBodyContentEncoding, contentType);
             }
             else if (contentType == Constants.FormContentHeader)
@@ -808,6 +870,34 @@ namespace CryptoExchange.Net.Clients
             return definition.FullUrl + definition + parameters?.ToFormData();
         }
 
+        /// <summary>
+        /// Whether a request can be coalesced or not
+        /// </summary>
+        protected virtual bool ShouldCoalesce(
+            RequestDefinition definition,
+            Dictionary<string, string>? additionalHeaders)
+        {
+            return ClientOptions.RequestCoalescingEnabled                       // Enabled in client options
+                && !definition.PreventRequestCoalescing                         // Enabled in request definition
+                && definition.Method == HttpMethod.Get                          // Is a GET request
+                && !definition.Authenticated                                    // Not an authenticated request
+                && (additionalHeaders == null || additionalHeaders.Count == 0); // No additional headers that might change the response
+        }
+
+        /// <summary>
+        /// Get a unique key for coalescing requests based on the request definition, parameters, and the type of the expected response.
+        /// </summary>
+        protected virtual RequestCoalescingKey GetRequestCoalescingKey<T>(
+            RequestDefinition definition,
+            Parameters? uriParameters)
+        {
+            return new RequestCoalescingKey(
+                definition.Method.Method,
+                definition.FullUrl,
+                uriParameters?.ToFormData(),
+                typeof(T));
+        }
+
         /// <inheritdoc />
         public virtual void SetOptions(UpdateOptions options)
         {

CryptoExchange.Net/ExtensionMethods.cs

@@ -4,6 +4,7 @@ using CryptoExchange.Net.SharedApis;
 using Microsoft.Extensions.DependencyInjection;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.IO;
 using System.IO.Compression;
@@ -387,14 +388,14 @@ 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(IWithdrawRest).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IWithdrawRest)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(ITransferRest).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ITransferRest)client(x)!);
 
             if (typeof(ISpotOrderRestClient).IsAssignableFrom(typeof(T)))
                 services.AddTransient(x => (ISpotOrderRestClient)client(x)!);
@@ -474,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(ISharedRest),
+                typeof(ISharedSocket),
+                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>

CryptoExchange.Net/Logging/Extensions/RestApiClientLoggingExtensions.cs

@@ -22,6 +22,7 @@ namespace CryptoExchange.Net.Logging.Extensions
         private static readonly Action<ILogger, string, Exception?> _restApiCacheHit;
         private static readonly Action<ILogger, string, Exception?> _restApiCacheNotHit;
         private static readonly Action<ILogger, int?, Exception?> _restApiCancellationRequested;
+        private static readonly Action<ILogger, string, string, Exception?> _restApiRequestsJoined;
 
         static RestApiClientLoggingExtensions()
         {
@@ -89,7 +90,11 @@ namespace CryptoExchange.Net.Logging.Extensions
                 LogLevel.Debug,
                 new EventId(4012, "RestApiCancellationRequested"),
                 "[Req {RequestId}] request cancelled by user");
-            
+
+            _restApiRequestsJoined = LoggerMessage.Define<string, string>(
+                LogLevel.Debug,
+                new EventId(4013, "RestApiRequestsJoined"),
+                "Request for {Method} {Path} joined with in flight request");
         }
 
         public static void RestApiErrorReceived(this ILogger logger, int? requestId, HttpStatusCode? responseStatusCode, long responseTime, string? error, string? originalData, Exception? exception)
@@ -151,9 +156,15 @@ namespace CryptoExchange.Net.Logging.Extensions
         {
             _restApiCacheNotHit(logger, key, null);
         }
+
         public static void RestApiCancellationRequested(this ILogger logger, int? requestId)
         {
             _restApiCancellationRequested(logger, requestId, null);
         }
+
+        public static void RestApiRequestsJoined(this ILogger logger, string method, string path)
+        {
+            _restApiRequestsJoined(logger, method, path, null);
+        }
     }
 }

CryptoExchange.Net/Objects/Options/RestExchangeOptions.cs

@@ -34,6 +34,11 @@ namespace CryptoExchange.Net.Objects.Options
             = new Version(1, 1);
 #endif
 
+        /// <summary>
+        /// Whether concurrent identical REST requests may share the same in-flight request when allowed by the request definition.
+        /// </summary>
+        public bool RequestCoalescingEnabled { get; set; } = true;
+
         /// <summary>
         /// Http client keep alive interval for keeping connections open. Only applied when using dotnet8.0 or higher and dependency injection
         /// </summary>
@@ -73,6 +78,7 @@ namespace CryptoExchange.Net.Objects.Options
             item.CachingEnabled = CachingEnabled;
             item.CachingMaxAge = CachingMaxAge;
             item.HttpVersion = HttpVersion;
+            item.RequestCoalescingEnabled = RequestCoalescingEnabled;
             item.HttpKeepAliveInterval = HttpKeepAliveInterval;
 #if NET5_0_OR_GREATER
             item.HttpMaxConnectionsPerServer = HttpMaxConnectionsPerServer;

CryptoExchange.Net/Objects/RequestCoalescer.cs

@@ -0,0 +1,277 @@
+using CryptoExchange.Net.Logging.Extensions;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Objects
+{
+    /// <summary>
+    /// Request coalescer, used to detect multiple identical requests and wait for and return only a single actual request result
+    /// </summary>
+    public class RequestCoalescer
+    {
+        private sealed class RequestEntry
+        {
+            public RequestCoalescingKey Key { get; }
+
+            public CancellationTokenSource CancellationSource { get; } = new();
+
+            public Lazy<Task<object>> Request { get; set; } = null!;
+
+            public int ListenerCount { get; set; }
+
+            public bool Completed { get; set; }
+
+            public bool CancellationInProgress { get; set; }
+
+            public bool Disposed { get; set; }
+
+            public RequestEntry(RequestCoalescingKey key)
+            {
+                Key = key;
+            }
+        }
+
+        private readonly object _sync = new();
+        private readonly ILogger _logger;
+
+        private readonly Dictionary<RequestCoalescingKey, RequestEntry> _requests = new();
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public RequestCoalescer(ILogger logger)
+        {
+            _logger = logger;
+        }
+
+        /// <summary>
+        /// Execute a request, coalescing identical requests into a single request
+        /// </summary>
+        public Task<TResult> ExecuteAsync<TResult>(
+            RequestCoalescingKey key,
+            Func<CancellationToken, Task<TResult>> requestFactory,
+            Func<TResult> cancellationResultFactory,
+            CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+                return Task.FromResult(cancellationResultFactory());
+
+            RequestEntry entry;
+            bool joined;
+
+            lock (_sync)
+            {
+                joined = _requests.TryGetValue(key, out entry!);
+
+                if (!joined)
+                {
+                    entry = CreateEntry(key, requestFactory);
+                    _requests.Add(key, entry);
+                }
+
+                entry.ListenerCount++;
+            }
+
+            if (joined)
+                _logger.RestApiRequestsJoined(key.Method, key.Url);
+
+            return WaitAsync(
+                entry,
+                cancellationResultFactory,
+                cancellationToken);
+        }
+
+        private RequestEntry CreateEntry<TResult>(
+            RequestCoalescingKey key,
+            Func<CancellationToken, Task<TResult>> requestFactory)
+        {
+            var entry = new RequestEntry(key);
+
+            entry.Request = new Lazy<Task<object>>(
+                () => ExecuteCoreAsync(
+                    entry,
+                    async requestCancellationToken =>
+                        (await requestFactory(requestCancellationToken).ConfigureAwait(false))!),
+                LazyThreadSafetyMode.ExecutionAndPublication);
+
+            return entry;
+        }
+
+        private async Task<object> ExecuteCoreAsync(
+            RequestEntry entry,
+            Func<CancellationToken, Task<object>> requestFactory)
+        {
+            try
+            {
+                return await requestFactory(entry.CancellationSource.Token).ConfigureAwait(false);
+            }
+            finally
+            {
+                CompleteRequest(entry);
+            }
+        }
+
+        private async Task<TResult> WaitAsync<TResult>(
+            RequestEntry entry,
+            Func<TResult> cancellationResultFactory,
+            CancellationToken cancellationToken)
+        {
+            try
+            {
+                var requestTask = entry.Request.Value;
+
+                if (!cancellationToken.CanBeCanceled)
+                    return (TResult)await requestTask.ConfigureAwait(false);
+
+                var cancellationCompletion = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+                using (cancellationToken.Register(
+                    state => ((TaskCompletionSource<bool>)state!).TrySetResult(true),
+                    cancellationCompletion))
+                {
+                    var completedTask = await Task.WhenAny(requestTask, cancellationCompletion.Task).ConfigureAwait(false);
+                    if (completedTask != requestTask)
+                        return cancellationResultFactory();
+                }
+
+                return (TResult)await requestTask.ConfigureAwait(false);
+            }
+            finally
+            {
+                ReleaseListener(entry);
+            }
+        }
+
+        private void ReleaseListener(RequestEntry entry)
+        {
+            var cancelRequest = false;
+            var disposeCancellationSource = false;
+
+            lock (_sync)
+            {
+                entry.ListenerCount--;
+
+                if (entry.ListenerCount == 0)
+                {
+                    if (!entry.Completed)
+                    {
+                        // Remove the entry before canceling it. A caller arriving
+                        // after this point must create a new physical request
+                        // instead of joining one that is being canceled.
+                        RemoveEntry(entry);
+
+                        entry.CancellationInProgress = true;
+                        cancelRequest = true;
+                    }
+                    else if (!entry.Disposed)
+                    {
+                        entry.Disposed = true;
+                        disposeCancellationSource = true;
+                    }
+                }
+            }
+
+            if (cancelRequest)
+            {
+                try
+                {
+                    entry.CancellationSource.Cancel();
+                }
+                catch (Exception exception)
+                {
+                    // Cancellation callbacks are external to the coalescer and
+                    // must not cause an exception to escape the library.
+                    _logger.LogWarning(
+                        exception,
+                        "Error canceling in-flight request {Method} {Url}",
+                        entry.Key.Method,
+                        entry.Key.Url);
+                }
+                finally
+                {
+                    CompleteCancellation(entry);
+                }
+            }
+            else if (disposeCancellationSource)
+            {
+                entry.CancellationSource.Dispose();
+            }
+        }
+
+        private void CompleteCancellation(RequestEntry entry)
+        {
+            var disposeCancellationSource = false;
+
+            lock (_sync)
+            {
+                entry.CancellationInProgress = false;
+
+                if (entry.Completed
+                    && entry.ListenerCount == 0
+                    && !entry.Disposed)
+                {
+                    entry.Disposed = true;
+                    disposeCancellationSource = true;
+                }
+            }
+
+            if (disposeCancellationSource)
+                entry.CancellationSource.Dispose();
+        }
+
+        private void CompleteRequest(RequestEntry entry)
+        {
+            var disposeCancellationSource = false;
+
+            lock (_sync)
+            {
+                entry.Completed = true;
+
+                // Only remove this specific entry. If all listeners canceled,
+                // a replacement request may already have been created for the
+                // same key.
+                RemoveEntry(entry);
+
+                if (entry.ListenerCount == 0
+                    && !entry.CancellationInProgress
+                    && !entry.Disposed)
+                {
+                    entry.Disposed = true;
+                    disposeCancellationSource = true;
+                }
+            }
+
+            if (disposeCancellationSource)
+                entry.CancellationSource.Dispose();
+        }
+
+        /// <summary>
+        /// Remove an entry when it is still the current entry for its key.
+        /// Must only be called while holding <see cref="_sync"/>.
+        /// </summary>
+        private void RemoveEntry(RequestEntry entry)
+        {
+            if (_requests.TryGetValue(entry.Key, out var current)
+                && ReferenceEquals(current, entry))
+            {
+                _requests.Remove(entry.Key);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Key used to identify identical requests for coalescing
+    /// </summary>
+    /// <param name="Method">Request method</param>
+    /// <param name="Url">Request URL</param>
+    /// <param name="Parameters">Request parameter string</param>
+    /// <param name="ResponseType">Response type</param>
+    public sealed record RequestCoalescingKey(
+        string Method,
+        string Url,
+        string? Parameters,
+        Type ResponseType);
+}

CryptoExchange.Net/Objects/RequestDefinition.cs

@@ -101,6 +101,11 @@ namespace CryptoExchange.Net.Objects
             }   
         }
 
+        /// <summary>
+        /// Whether concurrent identical requests should be prevented from sharing the same request/response
+        /// </summary>
+        public bool PreventRequestCoalescing { get; set; }
+
         /// <summary>
         /// ctor
         /// </summary>

CryptoExchange.Net/Objects/RequestDefinitionCache.cs

@@ -53,6 +53,7 @@ namespace CryptoExchange.Net.Objects
         /// <param name="tryParseOnNonSuccess">Try parse the response even when status is not success</param>
         /// <param name="forcePathEndWithSlash">Force trailing `/`</param>
         /// <param name="identifier">Optional request identifier override</param>
+        /// <param name="preventRequestCoalescing">Whether concurrent identical requests should be prevented from sharing the same request/response</param>
         /// <returns></returns>
         public RequestDefinition GetOrCreate(
             HttpMethod method,
@@ -68,7 +69,8 @@ namespace CryptoExchange.Net.Objects
             bool? preventCaching = null,
             bool? tryParseOnNonSuccess = null,
             bool? forcePathEndWithSlash = null,
-            string? identifier = null)
+            string? identifier = null,
+            bool? preventRequestCoalescing = null)
         {
             var identifierToUse = identifier ?? $"{path}{method.Method}{baseAddress}";
             if (!_definitions.TryGetValue(identifierToUse, out var def))
@@ -85,6 +87,7 @@ namespace CryptoExchange.Net.Objects
                     PreventCaching = preventCaching ?? false,
                     TryParseOnNonSuccess = tryParseOnNonSuccess ?? false,
                     ForcePathEndWithSlash = forcePathEndWithSlash ?? false,
+                    PreventRequestCoalescing = preventRequestCoalescing ?? false,
                 };
                 _definitions.TryAdd(identifierToUse, def);
             }

CryptoExchange.Net/Objects/Sockets/DataEvent.cs

@@ -165,7 +165,10 @@ namespace CryptoExchange.Net.Objects.Sockets
             {
                 StreamId = StreamId,
                 UpdateType = UpdateType,
-                Symbol = Symbol                
+                Symbol = Symbol,
+                DataTime = DataTime,
+                DataTimeLocal = DataTimeLocal,
+                SequenceNumber = SequenceNumber
             };
         }
 

CryptoExchange.Net/SharedApis/Enums/SharedOrderBookSubscriptionType.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// The type of updates the incremental order book subscription produces
+    /// </summary>
+    public enum SharedOrderBookSubscriptionType
+    {
+        /// <summary>
+        /// Subscription produces an initial snapshot update, followed by incremental change updates
+        /// </summary>
+        SnapshotThenIncremental,
+        /// <summary>
+        /// Subscription produces only incremental change updates
+        /// </summary>
+        OnlyIncremental
+    }
+}

CryptoExchange.Net/SharedApis/Enums/SharedTransport.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    public record SharedTransport(string Name)
+    {
+        public static SharedTransport Rest { get; } = new("REST");
+        public static SharedTransport Socket { get; } = new("WebSocket");
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/Legacy/ISharedClient.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// A shared/common client interface
+    /// </summary>
+    public interface ISharedClient : ISharedApi
+    {
+    }
+}

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

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Funding rate request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetFundingRateHistoryOptions GetFundingRateHistoryOptions { get; }

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

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Futures get order by client order id request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetFuturesOrderByClientOrderIdOptions GetFuturesOrderByClientOrderIdOptions { get; }
@@ -25,7 +25,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Futures cancel order by client order id request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         CancelFuturesOrderByClientOrderIdOptions CancelFuturesOrderByClientOrderIdOptions { get; }

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

@@ -38,7 +38,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Futures place order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         PlaceFuturesOrderOptions PlaceFuturesOrderOptions { get; }
@@ -52,7 +52,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Futures get order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetFuturesOrderOptions GetFuturesOrderOptions { get; }
@@ -65,7 +65,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Futures get open orders request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetOpenFuturesOrdersOptions GetOpenFuturesOrdersOptions { get; }
@@ -78,7 +78,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Spot get closed orders request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetFuturesClosedOrdersOptions GetClosedFuturesOrdersOptions { get; }
@@ -93,7 +93,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Futures get order trades request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetFuturesOrderTradesOptions GetFuturesOrderTradesOptions { get; }
@@ -106,10 +106,10 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Futures user trades request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
-        GetFuturesUserTradesOptions GetFuturesUserTradesOptions { get; }
+        GetFuturesUserTradeHistoryOptions GetFuturesUserTradesOptions { get; }
         /// <summary>
         /// Get futures user trade records, see <see cref="GetFuturesUserTradesOptions"/> for request options and exchange specific required/optional parameters. <br />
         /// The result is paginated, if there are more results to be retrieved, the `NextPageRequest` property of the result will contain the pagination request to be used for the next request to continue pagination.
@@ -121,7 +121,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Futures cancel order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         CancelFuturesOrderOptions CancelFuturesOrderOptions { get; }
@@ -134,7 +134,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Positions request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetPositionsOptions GetPositionsOptions { get; }
@@ -147,7 +147,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Close position order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         ClosePositionOptions ClosePositionOptions { get; }

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

@@ -16,7 +16,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Futures symbol request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetFuturesSymbolsOptions GetFuturesSymbolsOptions { get; }

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

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Futures get ticker request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetFuturesTickerOptions GetFuturesTickerOptions { get; }
@@ -24,10 +24,10 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Futures get tickers request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
-        GetFuturesTickersOptions 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/Futures/IFuturesTpSlRestClient.cs

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Set take profit and/or stop loss options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         SetFuturesTpSlOptions SetFuturesTpSlOptions { get; }
@@ -25,7 +25,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Cancel a take profit and/or stop loss options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         CancelFuturesTpSlOptions CancelFuturesTpSlOptions { get; }

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

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Place spot trigger order options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         PlaceFuturesTriggerOrderOptions PlaceFuturesTriggerOrderOptions { get; }
@@ -26,7 +26,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Get trigger order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetFuturesTriggerOrderOptions GetFuturesTriggerOrderOptions { get; }
@@ -39,7 +39,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Cancel trigger order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         CancelFuturesTriggerOrderOptions CancelFuturesTriggerOrderOptions { get; }

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

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Index price klines request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetIndexPriceKlinesOptions GetIndexPriceKlinesOptions { get; }

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

@@ -16,7 +16,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Leverage request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetLeverageOptions GetLeverageOptions { get; }
@@ -29,7 +29,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Leverage set request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         SetLeverageOptions SetLeverageOptions { get; }

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

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Mark price klines request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetMarkPriceKlinesOptions GetMarkPriceKlinesOptions { get; }

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

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Open interest request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetOpenInterestOptions GetOpenInterestOptions { get; }

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

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Position history request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetPositionHistoryOptions GetPositionHistoryOptions { get; }

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

@@ -16,7 +16,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Position mode request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetPositionModeOptions GetPositionModeOptions { get; }
@@ -29,7 +29,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Position mode set request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         SetPositionModeOptions SetPositionModeOptions { get; }

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Rest/IAssetsRestClient.cs

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Asset request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetAssetOptions GetAssetOptions { get; }
@@ -25,10 +25,10 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Assets request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
-        GetAssetsOptions GetAssetsOptions { get; }
+        GetAllAssetsOptions GetAssetsOptions { get; }
 
         /// <summary>
         /// Get info on all assets the exchange supports, see <see cref="GetAssetsOptions"/> for request options and exchange specific required/optional parameters. <br />

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Rest/IBalanceRestClient.cs

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Balances request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetBalancesOptions GetBalancesOptions { get; }

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Rest/IBookTickerRestClient.cs

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Book ticker request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetBookTickerOptions GetBookTickerOptions { get; }

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Rest/IDepositRestClient.cs

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Deposit addresses request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetDepositAddressesOptions GetDepositAddressesOptions { get; }
@@ -26,10 +26,10 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Deposits request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
-        GetDepositsOptions GetDepositsOptions { get; }
+        GetDepositHistoryOptions GetDepositsOptions { get; }
 
         /// <summary>
         /// Get deposit records, see <see cref="GetDepositsOptions"/> for request options and exchange specific required/optional parameters. <br />

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Rest/IFeeRestClient.cs

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Fee request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetFeeOptions GetFeeOptions { get; }

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Rest/IKlineRestClient.cs

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Kline request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetKlinesOptions GetKlinesOptions { get; }

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Rest/IOrderBookRestClient.cs

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Order book request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetOrderBookOptions GetOrderBookOptions { get; }

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Rest/IRecentTradeRestClient.cs

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Recent trades request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetRecentTradesOptions GetRecentTradesOptions { get; }

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Rest/ITradeHistoryRestClient.cs

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Trade history request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetTradeHistoryOptions GetTradeHistoryOptions { get; }

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Rest/ITransferRestClient.cs

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Transfer request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         TransferOptions TransferOptions { get; }
@@ -23,4 +23,4 @@ namespace CryptoExchange.Net.SharedApis
         /// <param name="ct">Cancellation token</param>
         Task<HttpResult<SharedId>> TransferAsync(TransferRequest request, CancellationToken ct = default);
     }
-}
+}

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Rest/IWithdrawRestClient.cs

@@ -1,17 +1,20 @@
 using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
-    /// Client for requesting to withdraw funds from the exchange
+    /// Client for withdrawing funds
     /// </summary>
     public interface IWithdrawRestClient : ISharedClient
     {
         /// <summary>
         /// Withdraw request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         WithdrawOptions WithdrawOptions { get; }
@@ -24,4 +27,4 @@ namespace CryptoExchange.Net.SharedApis
         /// <returns></returns>
         Task<HttpResult<SharedId>> WithdrawAsync(WithdrawRequest request, CancellationToken ct = default);
     }
-}
+}

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Rest/IWithdrawalRestClient.cs

@@ -11,10 +11,10 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Withdrawal records request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
-        GetWithdrawalsOptions GetWithdrawalsOptions { get; }
+        GetWithdrawalHistoryOptions GetWithdrawalsOptions { get; }
 
         /// <summary>
         /// Get withdrawal records, see <see cref="GetWithdrawalsOptions"/> for request options and exchange specific required/optional parameters. <br />

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

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Spot get order by client order id request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetSpotOrderByClientOrderIdOptions GetSpotOrderByClientOrderIdOptions { get; }
@@ -25,7 +25,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Spot cancel order by client order id request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         CancelSpotOrderByClientOrderIdOptions CancelSpotOrderByClientOrderIdOptions { get; }

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

@@ -38,7 +38,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Spot place order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         PlaceSpotOrderOptions PlaceSpotOrderOptions { get; }
@@ -51,7 +51,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Spot get order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetSpotOrderOptions GetSpotOrderOptions { get; }
@@ -64,7 +64,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Spot get open orders request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetOpenSpotOrdersOptions GetOpenSpotOrdersOptions { get; }
@@ -77,7 +77,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Spot get closed orders request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetSpotClosedOrdersOptions GetClosedSpotOrdersOptions { get; }
@@ -92,7 +92,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Spot get order trades request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetSpotOrderTradesOptions GetSpotOrderTradesOptions { get; }
@@ -106,10 +106,10 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Spot user trades request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
-        GetSpotUserTradesOptions GetSpotUserTradesOptions { get; }
+        GetSpotUserTradeHistoryOptions GetSpotUserTradesOptions { get; }
         /// <summary>
         /// Get spot user trade records, see <see cref="GetSpotUserTradesOptions"/> for request options and exchange specific required/optional parameters. <br />
         /// The result is paginated, if there are more results to be retrieved, the `NextPageRequest` property of the result will contain the pagination request to be used for the next request to continue pagination.
@@ -121,7 +121,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Spot cancel order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         CancelSpotOrderOptions CancelSpotOrderOptions { get; }

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

@@ -16,7 +16,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Spot symbols request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetSpotSymbolsOptions GetSpotSymbolsOptions { get; }

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

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Spot ticker request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetSpotTickerOptions GetSpotTickerOptions { get; }
@@ -23,10 +23,10 @@ namespace CryptoExchange.Net.SharedApis
         Task<HttpResult<SharedSpotTicker>> GetSpotTickerAsync(GetTickerRequest request, CancellationToken ct = default);
         /// <summary>
         /// Spot tickers request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
-        GetSpotTickersOptions 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>

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

@@ -11,7 +11,7 @@ namespace CryptoExchange.Net.SharedApis
     {
         /// <summary>
         /// Place spot trigger order options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         PlaceSpotTriggerOrderOptions PlaceSpotTriggerOrderOptions { get; }
@@ -26,7 +26,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Get trigger order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         GetSpotTriggerOrderOptions GetSpotTriggerOrderOptions { get; }
@@ -39,7 +39,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Cancel trigger order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         CancelSpotTriggerOrderOptions CancelSpotTriggerOrderOptions { get; }

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Socket/Futures/IFuturesOrderManagementSocketClient.cs

@@ -38,7 +38,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Futures place order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         PlaceFuturesOrderSocketOptions PlaceFuturesOrderOptions { get; }
@@ -52,7 +52,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Futures cancel order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         CancelFuturesOrderSocketOptions CancelFuturesOrderOptions { get; }

CryptoExchange.Net/SharedApis/Interfaces/Legacy/Socket/Spot/ISpotOrderManagementSocketClient.cs

@@ -38,7 +38,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Spot place order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         PlaceSpotOrderSocketOptions PlaceSpotOrderOptions { get; }
@@ -51,7 +51,7 @@ namespace CryptoExchange.Net.SharedApis
 
         /// <summary>
         /// Spot cancel order request options.<br />
-        /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />
+        /// 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>
         CancelSpotOrderSocketOptions CancelSpotOrderOptions { get; }

CryptoExchange.Net/SharedApis/Interfaces/V2/Assets/IGetAllAssetsRest.cs

@@ -0,0 +1,29 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving all assets supported on an exchange.
+    /// </summary>
+    public interface IGetAllAssetsRest : ISharedRest
+    {
+        /// <summary>
+        /// Assets request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetAllAssetsOptions GetAllAssetsOptions { get; }
+
+        /// <summary>
+        /// Get info on all assets the exchange supports, see <see cref="GetAllAssetsOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedAsset[]>> GetAllAssetsAsync(GetAssetsRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Assets/IGetAssetRest.cs

@@ -0,0 +1,29 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving an asset on an exchange.
+    /// </summary>
+    public interface IGetAssetRest : ISharedRest
+    {
+        /// <summary>
+        /// Asset request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetAssetOptions GetAssetOptions { get; }
+
+        /// <summary>
+        /// Get info on a specific asset, see <see cref="GetAssetOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedAsset>> GetAssetAsync(GetAssetRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Balances/IGetBalancesRest.cs

@@ -0,0 +1,30 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving user asset balances on an exchange.
+    /// </summary>
+    public interface IGetBalancesRest : ISharedRest
+    {
+        /// <summary>
+        /// Balances request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetBalancesOptions GetBalancesOptions { get; }
+
+        /// <summary>
+        /// Get balances for the user, see <see cref="GetBalancesOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <returns></returns>
+        Task<HttpResult<SharedBalance[]>> GetBalancesAsync(GetBalancesRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Balances/ISubscribeBalancesSocket.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for subscribing to user balance updates
+    /// </summary>
+    public interface ISubscribeBalancesSocket : ISharedSubscription
+    {
+        /// <summary>
+        /// Balance subscription options
+        /// </summary>
+        SubscribeBalanceOptions SubscribeBalanceOptions { get; }
+
+        /// <summary>
+        /// Subscribe to user balance updates
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="handler">Update handler</param>
+        /// <param name="ct">Cancellation token, can be used to stop the updates</param>
+        /// <returns></returns>
+        Task<WebSocketResult<UpdateSubscription>> SubscribeToBalanceUpdatesAsync(SubscribeBalancesRequest request, Action<DataEvent<SharedBalance[]>> handler, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Deposits/IGetDepositAddressesRest.cs

@@ -0,0 +1,30 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving user deposit addresses on an exchange.
+    /// </summary>
+    public interface IGetDepositAddressesRest : ISharedRest
+    {
+        /// <summary>
+        /// Deposit addresses request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetDepositAddressesOptions GetDepositAddressesOptions { get; }
+
+        /// <summary>
+        /// Get deposit addresses for an asset, see <see cref="GetDepositAddressesOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <returns></returns>
+        Task<HttpResult<SharedDepositAddress[]>> GetDepositAddressesAsync(GetDepositAddressesRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Deposits/IGetDepositHistoryRest.cs

@@ -0,0 +1,32 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving user deposit history on an exchange.
+    /// </summary>
+    public interface IGetDepositHistoryRest : ISharedRest
+    {
+        /// <summary>
+        /// Deposits request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetDepositHistoryOptions GetDepositHistoryOptions { get; }
+
+        /// <summary>
+        /// Get deposit records, see <see cref="GetDepositHistoryOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// The result is paginated, if there are more results to be retrieved, the <see cref="HttpResult{T}.NextPageRequest"/> property of the result will contain the pagination request to be used for the next request to continue pagination.
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="nextPageToken">The pagination request from the previous request result <see cref="HttpResult{T}.NextPageRequest"/> property to continue pagination</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <returns></returns>
+        Task<HttpResult<SharedDeposit[]>> GetDepositHistoryAsync(GetDepositsRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Fees/IGetFeesRest.cs

@@ -0,0 +1,29 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving user trading fees on an exchange.
+    /// </summary>
+    public interface IGetFeesRest : ISharedRest
+    {
+        /// <summary>
+        /// Fee request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetFeeOptions GetFeeOptions { get; }
+
+        /// <summary>
+        /// Get trading fees for a symbol, see <see cref="GetFeeOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedFee>> GetFeesAsync(GetFeeRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Funding/IGetFundingRateHistoryRest.cs

@@ -0,0 +1,30 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving funding rate history for a symbol on an exchange.
+    /// </summary>
+    public interface IGetFundingRateHistoryRest : ISharedRest
+    {
+        /// <summary>
+        /// Funding rate request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetFundingRateHistoryOptions GetFundingRateHistoryOptions { get; }
+        /// <summary>
+        /// Get funding rate records, see <see cref="GetFundingRateHistoryOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// The result is paginated, if there are more results to be retrieved, the <see cref="HttpResult{T}.NextPageRequest"/> property of the result will contain the pagination request to be used for the next request to continue pagination.
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="nextPageToken">The pagination request from the previous request result <see cref="HttpResult{T}.NextPageRequest"/> property to continue pagination</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedFundingRate[]>> GetFundingRateHistoryAsync(GetFundingRateHistoryRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/ISharedApi.cs

@@ -1,11 +1,12 @@
 using System;
+using System.Collections.Generic;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// A shared/common client interface
     /// </summary>
-    public interface ISharedClient
+    public interface ISharedApi
     {
         /// <summary>
         /// Name of the exchange
@@ -22,6 +23,16 @@ namespace CryptoExchange.Net.SharedApis
         /// </summary>
         bool Authenticated { get; }
 
+        /// <summary>
+        /// The underlying transport type used by this client
+        /// </summary>
+        SharedTransport Transport { get; }
+
+        /// <summary>
+        /// Capabilities and operations exposed by this API
+        /// </summary>
+        IReadOnlyCollection<CapabilityOptions> Capabilities { get; }
+
         /// <summary>
         /// Get info on the client and supported features
         /// </summary>

CryptoExchange.Net/SharedApis/Interfaces/V2/ISharedApiCapability.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Interface for a shared API capability
+    /// </summary>
+    public interface ISharedApiCapability : ISharedApi
+    {
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/ISharedRest.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Interface for a shared API endpoint
+    /// </summary>
+    public interface ISharedRest : ISharedApiCapability
+    {
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/ISharedSocket.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Interface for a shared socket operation
+    /// </summary>
+    public interface ISharedSocket : ISharedApiCapability
+    {
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/ISharedSubscription.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Identifies a fine-grained Shared API subscription capability.
+    /// </summary>
+    public interface ISharedSubscription : ISharedSocket
+    {
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Klines/Futures/IGetIndexPriceKlinesRest.cs

@@ -0,0 +1,30 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving index price kline/candlestick data from an exchange
+    /// </summary>
+    public interface IGetIndexPriceKlinesRest : ISharedRest
+    {
+        /// <summary>
+        /// Index price klines request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetIndexPriceKlinesOptions GetIndexPriceKlinesOptions { get; }
+        /// <summary>
+        /// Get index price kline/candlestick data, see <see cref="GetIndexPriceKlinesOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// The result is paginated, if there are more results to be retrieved, the <see cref="HttpResult{T}.NextPageRequest"/> property of the result will contain the pagination request to be used for the next request to continue pagination.
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="nextPageToken">The pagination request from the previous request result <see cref="HttpResult{T}.NextPageRequest"/> property to continue pagination</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedFuturesKline[]>> GetIndexPriceKlinesAsync(GetKlinesRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Klines/Futures/IGetMarkPriceKlinesRest.cs

@@ -0,0 +1,30 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving mark price kline/candlestick data from an exchange.
+    /// </summary>
+    public interface IGetMarkPriceKlinesRest : ISharedRest
+    {
+        /// <summary>
+        /// Mark price klines request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetMarkPriceKlinesOptions GetMarkPriceKlinesOptions { get; }
+        /// <summary>
+        /// Get mark price kline/candlestick data, see <see cref="GetMarkPriceKlinesOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// The result is paginated, if there are more results to be retrieved, the <see cref="HttpResult{T}.NextPageRequest"/> property of the result will contain the pagination request to be used for the next request to continue pagination.
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="nextPageToken">The pagination request from the previous request result <see cref="HttpResult{T}.NextPageRequest"/> property to continue pagination</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedFuturesKline[]>> GetMarkPriceKlinesAsync(GetKlinesRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Klines/IGetKlinesRest.cs

@@ -0,0 +1,32 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Request definition for getting kline/candlestick data from an exchange.
+    /// </summary>
+    public interface IGetKlinesRest : ISharedRest
+    {
+        /// <summary>
+        /// Kline request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetKlinesOptions GetKlinesOptions { get; }
+
+        /// <summary>
+        /// Get kline/candlestick data, see <see cref="GetKlinesOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// The result is paginated, if there are more results to be retrieved, the <see cref="HttpResult{T}.NextPageRequest"/> property of the result will contain the pagination request to be used for the next request to continue pagination.
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="nextPageToken">The pagination request from the previous request result <see cref="HttpResult{T}.NextPageRequest"/> property to continue pagination</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <returns></returns>
+        Task<HttpResult<SharedKline[]>> GetKlinesAsync(GetKlinesRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Klines/ISubscribeKlinesSocket.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Threading.Tasks;
+using System.Threading;
+using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Objects;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for subscribing to kline/candlestick updates for a symbol
+    /// </summary>
+    public interface ISubscribeKlinesSocket : ISharedSubscription
+    {
+        /// <summary>
+        /// Kline subscription options
+        /// </summary>
+        SubscribeKlineOptions SubscribeKlineOptions { get; }
+
+        /// <summary>
+        /// Subscribe to kline/candlestick updates for a symbol
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="handler">Update handler</param>
+        /// <param name="ct">Cancellation token, can be used to stop the updates</param>
+        /// <returns></returns>
+        Task<WebSocketResult<UpdateSubscription>> SubscribeToKlineUpdatesAsync(SubscribeKlineRequest request, Action<DataEvent<SharedKline>> handler, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Leverage/IGetLeverageRest.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving leverage information for a symbol on an exchange.
+    /// </summary>
+    public interface IGetLeverageRest : ISharedRest
+    {
+        /// <summary>
+        /// Leverage request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetLeverageOptions GetLeverageOptions { get; }
+        /// <summary>
+        /// Get the current leverage setting for a symbol, see <see cref="GetLeverageOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedLeverage>> GetLeverageAsync(GetLeverageRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Leverage/ISetLeverageRest.cs

@@ -0,0 +1,33 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for setting leverage on an exchange.
+    /// </summary>
+    public interface ISetLeverageRest : ISharedRest
+    {
+        /// <summary>
+        /// How the leverage setting is configured on the exchange
+        /// </summary>
+        SharedLeverageSettingMode LeverageSettingType { get; }
+
+        /// <summary>
+        /// Leverage set request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        SetLeverageOptions SetLeverageOptions { get; }
+        /// <summary>
+        /// Set the leverage for a symbol, see <see cref="SetLeverageOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedLeverage>> SetLeverageAsync(SetLeverageRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/OpenInterest/IGetOpenInterestRest.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving open interest data from an exchange
+    /// </summary>
+    public interface IGetOpenInterestRest : ISharedRest
+    {
+        /// <summary>
+        /// Open interest request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetOpenInterestOptions GetOpenInterestOptions { get; }
+        /// <summary>
+        /// Get the open interest for a symbol, see <see cref="GetOpenInterestOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedOpenInterest>> GetOpenInterestAsync(GetOpenInterestRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/OrderBooks/IGetBookTickerRest.cs

@@ -0,0 +1,30 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Request definition for retrieving the best bid/ask prices for a symbol on an exchange.
+    /// </summary>
+    public interface IGetBookTickerRest : ISharedRest
+    {
+        /// <summary>
+        /// Book ticker request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetBookTickerOptions GetBookTickerOptions { get; }
+
+        /// <summary>
+        /// Get the best ask/bid info for a symbol, see <see cref="GetBookTickerOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <returns></returns>
+        Task<HttpResult<SharedBookTicker>> GetBookTickerAsync(GetBookTickerRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/OrderBooks/IGetOrderBookRest.cs

@@ -0,0 +1,30 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Request definition for retrieving an order book snapshot for a symbol on an exchange.
+    /// </summary>
+    public interface IGetOrderBookRest : ISharedRest
+    {
+        /// <summary>
+        /// Order book request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetOrderBookOptions GetOrderBookOptions { get; }
+
+        /// <summary>
+        /// Get the order book for a symbol, see <see cref="GetOrderBookOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <returns></returns>
+        Task<HttpResult<SharedOrderBook>> GetOrderBookAsync(GetOrderBookRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/OrderBooks/ISubscribeIncrementalOrderBookSocket.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for subscribing to incremental order book updates for a symbol
+    /// </summary>
+    public interface ISubscribeIncrementalOrderBookSocket : ISharedSubscription
+    {
+        /// <summary>
+        /// Order book subscription options
+        /// </summary>
+        SubscribeOrderBookOptions SubscribeOrderBookOptions { get; }
+
+        /// <summary>
+        /// Subscribe to incremental order book updates for a symbol
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="handler">Update handler</param>
+        /// <param name="ct">Cancellation token, can be used to stop the updates</param>
+        /// <returns></returns>
+        Task<WebSocketResult<UpdateSubscription>> SubscribeToOrderBookUpdatesAsync(SubscribeOrderBookRequest request, Action<DataEvent<SharedOrderBook>> handler, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/OrderBooks/ISubscribeOrderBookSocket.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for subscribing to order book snapshot updates for a symbol
+    /// </summary>
+    public interface ISubscribeOrderBookSocket : ISharedSubscription
+    {
+        /// <summary>
+        /// Order book subscription options
+        /// </summary>
+        SubscribeOrderBookOptions SubscribeOrderBookOptions { get; }
+
+        /// <summary>
+        /// Subscribe to order book snapshot updates for a symbol
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="handler">Update handler</param>
+        /// <param name="ct">Cancellation token, can be used to stop the updates</param>
+        /// <returns></returns>
+        Task<WebSocketResult<UpdateSubscription>> SubscribeToOrderBookUpdatesAsync(SubscribeOrderBookRequest request, Action<DataEvent<SharedOrderBook>> handler, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Futures/ICancelFuturesOrderByClientOrderIdRest.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for canceling a futures order by client order id on an exchange.
+    /// </summary>
+    public interface ICancelFuturesOrderByClientOrderIdRest : ISharedRest
+    {
+        /// <summary>
+        /// Futures cancel order by client order id request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        CancelFuturesOrderByClientOrderIdOptions CancelFuturesOrderByClientOrderIdOptions { get; }
+        /// <summary>
+        /// Cancel a futures order using client order id, see <see cref="CancelFuturesOrderByClientOrderIdOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedId>> CancelFuturesOrderByClientOrderIdAsync(CancelOrderRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Futures/ICancelFuturesOrderRest.cs

@@ -0,0 +1,29 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for canceling a futures order on an exchange.
+    /// </summary>
+    public interface ICancelFuturesOrderRest : ISharedRest
+    {
+        /// <summary>
+        /// Futures cancel order request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        CancelFuturesOrderOptions CancelFuturesOrderOptions { get; }
+        /// <summary>
+        /// Cancel a futures order, see <see cref="CancelFuturesOrderOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedId>> CancelFuturesOrderAsync(CancelOrderRequest request, CancellationToken ct = default);
+
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Futures/ICancelFuturesOrderSocket.cs

@@ -0,0 +1,25 @@
+using CryptoExchange.Net.Objects;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for placing and managing futures orders
+    /// </summary>
+    public interface ICancelFuturesOrderSocket : ISharedSocket
+    {
+        /// <summary>
+        /// Futures cancel order request options.<br />
+        /// 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>
+        CancelFuturesOrderSocketOptions CancelFuturesOrderOptions { get; }
+        /// <summary>
+        /// Cancel a futures order, see <see cref="CancelFuturesOrderOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<QueryResult<SharedId>> CancelFuturesOrderAsync(CancelOrderRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Futures/IGetClosedFuturesOrdersRest.cs

@@ -0,0 +1,30 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving closed futures orders on an exchange.
+    /// </summary>
+    public interface IGetClosedFuturesOrdersRest : ISharedRest
+    {
+        /// <summary>
+        /// Spot get closed orders request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetFuturesClosedOrdersOptions GetClosedFuturesOrdersOptions { get; }
+        /// <summary>
+        /// Get info on closed futures orders, see <see cref="GetClosedFuturesOrdersOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// The result is paginated, if there are more results to be retrieved, the <see cref="HttpResult{T}.NextPageRequest"/> property of the result will contain the pagination request to be used for the next request to continue pagination.
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="nextPageToken">The pagination request from the previous request result <see cref="HttpResult{T}.NextPageRequest"/> property to continue pagination</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedFuturesOrder[]>> GetClosedFuturesOrdersAsync(GetClosedOrdersRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Futures/IGetFuturesOrderByClientOrderIdRest.cs

@@ -0,0 +1,29 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving a futures order by client order id on an exchange.
+    /// </summary>
+    public interface IGetFuturesOrderByClientOrderIdRest : ISharedRest
+    {
+        /// <summary>
+        /// Futures get order by client order id request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetFuturesOrderByClientOrderIdOptions GetFuturesOrderByClientOrderIdOptions { get; }
+
+        /// <summary>
+        /// Get info on a specific futures order using a client order id, see <see cref="GetFuturesOrderByClientOrderIdOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedFuturesOrder>> GetFuturesOrderByClientOrderIdAsync(GetOrderRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Futures/IGetFuturesOrderRest.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving a futures order on an exchange.
+    /// </summary>
+    public interface IGetFuturesOrderRest : ISharedRest
+    {
+        /// <summary>
+        /// Futures get order request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetFuturesOrderOptions GetFuturesOrderOptions { get; }
+        /// <summary>
+        /// Get info on a specific futures order, see <see cref="GetFuturesOrderOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedFuturesOrder>> GetFuturesOrderAsync(GetOrderRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Futures/IGetOpenFuturesOrdersRest.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for retrieving open futures orders on an exchange.
+    /// </summary>
+    public interface IGetOpenFuturesOrdersRest : ISharedRest
+    {
+        /// <summary>
+        /// Futures get open orders request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetOpenFuturesOrdersOptions GetOpenFuturesOrdersOptions { get; }
+        /// <summary>
+        /// Get info on a open futures orders, see <see cref="GetOpenFuturesOrdersOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedFuturesOrder[]>> GetOpenFuturesOrdersAsync(GetOpenOrdersRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Futures/IPlaceFuturesOrderRest.cs

@@ -0,0 +1,56 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Endpoint definition for placing a futures order on an exchange.
+    /// </summary>
+    public interface IPlaceFuturesOrderRest : ISharedRest
+    {
+        /// <summary>
+        /// How the trading fee is deducted
+        /// </summary>
+        SharedFeeDeductionType FuturesFeeDeductionType { get; }
+        /// <summary>
+        /// How the asset is determined in which the trading fee is paid
+        /// </summary>
+        SharedFeeAssetType FuturesFeeAssetType { get; }
+        /// <summary>
+        /// Supported order types for futures orders
+        /// </summary>
+        SharedOrderType[] FuturesSupportedOrderTypes { get; }
+        /// <summary>
+        /// Supported time in force types for futures orders
+        /// </summary>
+        SharedTimeInForce[] FuturesSupportedTimeInForce { get; }
+        /// <summary>
+        /// Supported quantity types for futures orders
+        /// </summary>
+        SharedQuantitySupport FuturesSupportedOrderQuantity { get; }
+
+        /// <summary>
+        /// Generate a new random client order id
+        /// </summary>
+        /// <returns></returns>
+        string GenerateClientOrderId();
+
+        /// <summary>
+        /// Futures place order request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        PlaceFuturesOrderOptions PlaceFuturesOrderOptions { get; }
+
+        /// <summary>
+        /// Place a new futures order, see <see cref="PlaceFuturesOrderOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedId>> PlaceFuturesOrderAsync(PlaceFuturesOrderRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Futures/IPlaceFuturesOrderSocket.cs

@@ -0,0 +1,54 @@
+using CryptoExchange.Net.Objects;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for placing and managing futures orders
+    /// </summary>
+    public interface IPlaceFuturesOrderSocket : ISharedSocket
+    {
+        /// <summary>
+        /// How the trading fee is deducted
+        /// </summary>
+        SharedFeeDeductionType FuturesFeeDeductionType { get; }
+        /// <summary>
+        /// How the asset is determined in which the trading fee is paid
+        /// </summary>
+        SharedFeeAssetType FuturesFeeAssetType { get; }
+        /// <summary>
+        /// Supported order types for futures orders
+        /// </summary>
+        SharedOrderType[] FuturesSupportedOrderTypes { get; }
+        /// <summary>
+        /// Supported time in force types for futures orders
+        /// </summary>
+        SharedTimeInForce[] FuturesSupportedTimeInForce { get; }
+        /// <summary>
+        /// Supported quantity types for futures orders
+        /// </summary>
+        SharedQuantitySupport FuturesSupportedOrderQuantity { get; }
+
+        /// <summary>
+        /// Generate a new random client order id
+        /// </summary>
+        /// <returns></returns>
+        string GenerateClientOrderId();
+
+        /// <summary>
+        /// Futures place order request options.<br />
+        /// 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>
+        PlaceFuturesOrderSocketOptions PlaceFuturesOrderOptions { get; }
+
+        /// <summary>
+        /// Place a new futures order, see <see cref="PlaceFuturesOrderOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<QueryResult<SharedId>> PlaceFuturesOrderAsync(PlaceFuturesOrderRequest request, CancellationToken ct = default);
+
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Futures/ISubscribeFuturesOrdersSocket.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for subscribing to user futures order updates
+    /// </summary>
+    public interface ISubscribeFuturesOrdersSocket : ISharedSubscription
+    {
+        /// <summary>
+        /// Futures orders subscription options
+        /// </summary>
+        SubscribeFuturesOrderOptions SubscribeFuturesOrderOptions { get; }
+
+        /// <summary>
+        /// Subscribe to user futures order updates
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="handler">Update handler</param>
+        /// <param name="ct">Cancellation token, can be used to stop the updates</param>
+        /// <returns></returns>
+        Task<WebSocketResult<UpdateSubscription>> SubscribeToFuturesOrderUpdatesAsync(SubscribeFuturesOrderRequest request, Action<DataEvent<SharedFuturesOrderUpdate[]>> handler, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Futures/ISubscribePositionsSocket.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Threading.Tasks;
+using System.Threading;
+using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Objects;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for subscribing to position updates
+    /// </summary>
+    public interface ISubscribePositionsSocket : ISharedSubscription
+    {
+        /// <summary>
+        /// Position subscription options
+        /// </summary>
+        SubscribePositionOptions SubscribePositionOptions { get; }
+
+        /// <summary>
+        /// Subscribe to user position updates
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="handler">Update handler</param>
+        /// <param name="ct">Cancellation token, can be used to stop the updates</param>
+        /// <returns></returns>
+        Task<WebSocketResult<UpdateSubscription>> SubscribeToPositionUpdatesAsync(SubscribePositionRequest request, Action<DataEvent<SharedPosition[]>> handler, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Spot/ICancelSpotOrderByClientOrderIdRest.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Request definition for canceling a spot order by client order id on an exchange.
+    /// </summary>
+    public interface ICancelSpotOrderByClientOrderIdRest : ISharedRest
+    {
+        /// <summary>
+        /// Spot cancel order by client order id request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        CancelSpotOrderByClientOrderIdOptions CancelSpotOrderByClientOrderIdOptions { get; }
+        /// <summary>
+        /// Cancel a spot order using client order id, see <see cref="CancelSpotOrderByClientOrderIdOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedId>> CancelSpotOrderByClientOrderIdAsync(CancelOrderRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Spot/ICancelSpotOrderRest.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Request definition for canceling a spot order on an exchange.
+    /// </summary>
+    public interface ICancelSpotOrderRest : ISharedRest
+    {
+        /// <summary>
+        /// Spot cancel order request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        CancelSpotOrderOptions CancelSpotOrderOptions { get; }
+        /// <summary>
+        /// Cancel a spot order, see <see cref="CancelSpotOrderOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedId>> CancelSpotOrderAsync(CancelOrderRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Spot/ICancelSpotOrderSocket.cs

@@ -0,0 +1,26 @@
+using CryptoExchange.Net.Objects;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for placing and managing spot orders
+    /// </summary>
+    public interface ICancelSpotOrderSocket : ISharedSocket
+    {
+        /// <summary>
+        /// Spot cancel order request options.<br />
+        /// 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>
+        CancelSpotOrderSocketOptions CancelSpotOrderOptions { get; }
+        /// <summary>
+        /// Cancel a spot order, see <see cref="CancelSpotOrderOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<QueryResult<SharedId>> CancelSpotOrderAsync(CancelOrderRequest request, CancellationToken ct = default);
+
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Spot/IGetClosedSpotOrdersRest.cs

@@ -0,0 +1,30 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Request definition for retrieving closed spot orders from an exchange.
+    /// </summary>
+    public interface IGetClosedSpotOrdersRest : ISharedRest
+    {
+        /// <summary>
+        /// Spot get closed orders request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetSpotClosedOrdersOptions GetClosedSpotOrdersOptions { get; }
+        /// <summary>
+        /// Get info on closed spot orders, see <see cref="GetClosedSpotOrdersOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// The result is paginated, if there are more results to be retrieved, the <see cref="HttpResult{T}.NextPageRequest"/> property of the result will contain the pagination request to be used for the next request to continue pagination.
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="nextPageToken">The pagination request from the previous request result <see cref="HttpResult{T}.NextPageRequest"/> property to continue pagination</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedSpotOrder[]>> GetClosedSpotOrdersAsync(GetClosedOrdersRequest request, PageRequest? nextPageToken = null, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Spot/IGetOpenSpotOrdersRest.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Request definition for retrieving open spot order from an exchange.
+    /// </summary>
+    public interface IGetOpenSpotOrdersRest : ISharedRest
+    {
+        /// <summary>
+        /// Spot get open orders request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetOpenSpotOrdersOptions GetOpenSpotOrdersOptions { get; }
+        /// <summary>
+        /// Get info on a open spot orders, see <see cref="GetOpenSpotOrdersOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedSpotOrder[]>> GetOpenSpotOrdersAsync(GetOpenOrdersRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Spot/IGetSpotOrderByClientOrderIdRest.cs

@@ -0,0 +1,30 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Request definition for retrieving a spot order by client order id from an exchange.
+    /// </summary>
+    public interface IGetSpotOrderByClientOrderIdRest : ISharedRest
+    {
+        /// <summary>
+        /// Spot get order by client order id request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetSpotOrderByClientOrderIdOptions GetSpotOrderByClientOrderIdOptions { get; }
+
+        /// <summary>
+        /// Get info on a specific spot order using a client order id, see <see cref="GetSpotOrderByClientOrderIdOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedSpotOrder>> GetSpotOrderByClientOrderIdAsync(GetOrderRequest request, CancellationToken ct = default);
+
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Spot/IGetSpotOrderRest.cs

@@ -0,0 +1,28 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Request definition for retrieving a spot order from an exchange.
+    /// </summary>
+    public interface IGetSpotOrderRest : ISharedRest
+    {
+        /// <summary>
+        /// Spot get order request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        GetSpotOrderOptions GetSpotOrderOptions { get; }
+        /// <summary>
+        /// Get info on a specific spot order, see <see cref="GetSpotOrderOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        Task<HttpResult<SharedSpotOrder>> GetSpotOrderAsync(GetOrderRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Spot/IPlaceSpotOrder.cs

@@ -0,0 +1,50 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    public interface IPlaceSpotOrder : ISharedApiCapability
+    {
+        /// <summary>
+        /// How the trading fee is deducted
+        /// </summary>
+        SharedFeeDeductionType SpotFeeDeductionType { get; }
+        /// <summary>
+        /// How the asset is determined in which the trading fee is paid
+        /// </summary>
+        SharedFeeAssetType SpotFeeAssetType { get; }
+        /// <summary>
+        /// Supported order types for spot orders
+        /// </summary>
+        SharedOrderType[] SpotSupportedOrderTypes { get; }
+        /// <summary>
+        /// Supported time in force types for placing spot orders
+        /// </summary>
+        SharedTimeInForce[] SpotSupportedTimeInForce { get; }
+        /// <summary>
+        /// Supported quantity types for placing spot orders
+        /// </summary>
+        SharedQuantitySupport SpotSupportedOrderQuantity { get; }
+
+        /// <summary>
+        /// Generate a new random client order id in a format that is accepted by the exchange.
+        /// </summary>
+        /// <returns></returns>
+        string GenerateClientOrderId();
+
+        /// <summary>
+        /// Spot place order request options.<br />
+        /// Use <see cref="CapabilityOptions.RequiredRequestParameters"/>, <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>
+        PlaceSpotOrderOptions PlaceSpotOrderOptions { get; }
+
+        Task<ICallResult<SharedId>> PlaceSpotOrderAsync(
+            PlaceSpotOrderRequest request,
+            CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Spot/IPlaceSpotOrderRest.cs

@@ -0,0 +1,22 @@
+using CryptoExchange.Net.Objects;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Request definition for placing a spot order on an exchange.
+    /// </summary>
+    public interface IPlaceSpotOrderRest : IPlaceSpotOrder, ISharedRest
+    {        
+        /// <summary>
+        /// Place a new spot order, see <see cref="PlaceSpotOrderOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        new Task<HttpResult<SharedId>> PlaceSpotOrderAsync(PlaceSpotOrderRequest request, CancellationToken ct = default);
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/V2/Orders/Spot/IPlaceSpotOrderSocket.cs

@@ -0,0 +1,19 @@
+using CryptoExchange.Net.Objects;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Client for placing and managing spot orders
+    /// </summary>
+    public interface IPlaceSpotOrderSocket : IPlaceSpotOrder, ISharedSocket
+    {
+        /// <summary>
+        /// Place a new spot order, see <see cref="PlaceSpotOrderOptions"/> for request options and exchange specific required/optional parameters. <br />
+        /// </summary>
+        /// <param name="request">Request info</param>
+        /// <param name="ct">Cancellation token</param>
+        new Task<QueryResult<SharedId>> PlaceSpotOrderAsync(PlaceSpotOrderRequest request, CancellationToken ct = default);        
+    }
+}