Added UsdtFuturesV5Api Rest+Socket client

HTX.Net/Clients/HTXRestClient.cs

@@ -5,6 +5,8 @@
 using CryptoExchange.Net.Clients;
 using HTX.Net.Interfaces.Clients.UsdtFuturesApi;
 using HTX.Net.Clients.UsdtFutures;
+using HTX.Net.Clients.UsdtFuturesV5;
+using HTX.Net.Interfaces.Clients.UsdtFuturesV5Api;
 using Microsoft.Extensions.Options;
 using CryptoExchange.Net.Objects.Options;
 
@@ -21,6 +23,9 @@ public class HTXRestClient : BaseRestClient<HTXEnvironment, HTXCredentials>, IHT
         /// <inheritdoc />
         public IHTXRestClientUsdtFuturesApi UsdtFuturesApi { get; }
 
+        /// <inheritdoc />
+        public IHTXRestClientUsdtFuturesV5Api UsdtFuturesV5Api { get; }
+
         #endregion
 
         #region constructor/destructor
@@ -46,6 +51,7 @@ public HTXRestClient(HttpClient? httpClient, ILoggerFactory? loggerFactory, IOpt
 
             SpotApi = AddApiClient(new HTXRestClientSpotApi(_logger, httpClient, options.Value));
             UsdtFuturesApi = AddApiClient(new HTXRestClientUsdtFuturesApi(_logger, httpClient, options.Value));
+            UsdtFuturesV5Api = AddApiClient(new HTXRestClientUsdtFuturesV5Api(_logger, httpClient, options.Value));
         }
         #endregion
 

HTX.Net/Clients/HTXSocketClient.cs

@@ -2,9 +2,11 @@
 using CryptoExchange.Net.Objects.Options;
 using HTX.Net.Clients.SpotApi;
 using HTX.Net.Clients.UsdtFutures;
+using HTX.Net.Clients.UsdtFuturesV5;
 using HTX.Net.Interfaces.Clients;
 using HTX.Net.Interfaces.Clients.SpotApi;
 using HTX.Net.Interfaces.Clients.UsdtFuturesApi;
+using HTX.Net.Interfaces.Clients.UsdtFuturesV5Api;
 using HTX.Net.Objects.Options;
 using Microsoft.Extensions.Options;
 
@@ -18,6 +20,8 @@ public class HTXSocketClient : BaseSocketClient<HTXEnvironment, HTXCredentials>,
         public IHTXSocketClientSpotApi SpotApi { get; }
         /// <inheritdoc />
         public IHTXSocketClientUsdtFuturesApi UsdtFuturesApi { get; }
+        /// <inheritdoc />
+        public IHTXSocketClientUsdtFuturesV5Api UsdtFuturesV5Api { get; }
         #endregion
 
         #region ctor
@@ -42,6 +46,7 @@ public HTXSocketClient(IOptions<HTXSocketOptions> options, ILoggerFactory? logge
 
             SpotApi = AddApiClient(new HTXSocketClientSpotApi(_logger, options.Value));
             UsdtFuturesApi = AddApiClient(new HTXSocketClientUsdtFuturesApi(_logger, options.Value));
+            UsdtFuturesV5Api = AddApiClient(new HTXSocketClientUsdtFuturesV5Api(_logger, options.Value));
         }
         #endregion
 

HTX.Net/Clients/UsdtFuturesV5/HTXRestClientUsdtFuturesV5Api.cs

@@ -0,0 +1,78 @@
+using CryptoExchange.Net.Clients;
+using CryptoExchange.Net.Converters.MessageParsing;
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
+using CryptoExchange.Net.Objects.Errors;
+using CryptoExchange.Net.SharedApis;
+using HTX.Net.Clients.MessageHandlers;
+using HTX.Net.Interfaces.Clients.UsdtFuturesV5Api;
+using HTX.Net.Objects.Internal;
+using HTX.Net.Objects.Options;
+
+namespace HTX.Net.Clients.UsdtFuturesV5
+{
+    /// <inheritdoc />
+    internal partial class HTXRestClientUsdtFuturesV5Api : RestApiClient<HTXEnvironment, HTXAuthenticationProvider, HTXCredentials>, IHTXRestClientUsdtFuturesV5Api
+    {
+        /// <inheritdoc />
+        public new HTXRestOptions ClientOptions => (HTXRestOptions)base.ClientOptions;
+
+        protected override ErrorMapping ErrorMapping => HTXErrors.FuturesMapping;
+
+        protected override IRestMessageHandler MessageHandler => new HTXRestMessageHandler(HTXErrors.FuturesMapping);
+
+        /// <inheritdoc />
+        public string ExchangeName => "HTX";
+
+        #region Api clients
+
+        /// <inheritdoc />
+        public IHTXRestClientUsdtFuturesV5ApiAccount Account { get; }
+        /// <inheritdoc />
+        public IHTXRestClientUsdtFuturesV5ApiExchangeData ExchangeData { get; }
+        /// <inheritdoc />
+        public IHTXRestClientUsdtFuturesV5ApiTrading Trading { get; }
+
+        #endregion
+
+        #region constructor/destructor
+        internal HTXRestClientUsdtFuturesV5Api(ILogger log, HttpClient? httpClient, HTXRestOptions options)
+            : base(log, httpClient, options.Environment.UsdtMarginSwapRestBaseAddress, options, options.UsdtFuturesV5Options)
+        {
+            Account = new HTXRestClientUsdtFuturesV5ApiAccount(this);
+            ExchangeData = new HTXRestClientUsdtFuturesV5ApiExchangeData(this);
+            Trading = new HTXRestClientUsdtFuturesV5ApiTrading(this);
+        }
+        #endregion
+
+        protected override IMessageSerializer CreateSerializer() => new SystemTextJsonMessageSerializer(SerializerOptions.WithConverters(HTXExchange._serializerContext));
+
+        /// <inheritdoc />
+        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode tradingMode, DateTime? deliverTime = null)
+                => HTXExchange.FormatSymbol(baseAsset, quoteAsset, tradingMode, deliverTime);
+
+        /// <inheritdoc />
+        protected override HTXAuthenticationProvider CreateAuthenticationProvider(HTXCredentials credentials)
+            => new HTXAuthenticationProvider(credentials, ClientOptions.SignPublicRequests);
+
+        internal Task<WebCallResult<T>> SendAsync<T>(RequestDefinition definition, ParameterCollection? parameters, CancellationToken cancellationToken, int? weight = null)
+            where T : class
+            => SendToAddressAsync<T>(BaseAddress, definition, parameters, cancellationToken, weight);
+
+        internal async Task<WebCallResult<T>> SendToAddressAsync<T>(string baseAddress, RequestDefinition definition, ParameterCollection? parameters, CancellationToken cancellationToken, int? weight = null)
+            where T : class
+        {
+            var result = await base.SendAsync<HTXApiResponseV2<T>>(baseAddress, definition, parameters, cancellationToken, null, weight).ConfigureAwait(false);
+            if (!result || result.Data == null)
+                return result.AsError<T>(result.Error!);
+
+            if (result.Data.Code != 200)
+                return result.AsError<T>(new ServerError(result.Data.Code, GetErrorInfo(result.Data.Code, result.Data.Message)));
+
+            return result.As(result.Data.Data);
+        }
+
+        /// <inheritdoc />
+        protected override Task<WebCallResult<DateTime>> GetServerTimestampAsync()
+            => Task.FromResult(new WebCallResult<DateTime>(null, null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, DateTime.UtcNow, null));
+    }
+}

HTX.Net/Clients/UsdtFuturesV5/HTXRestClientUsdtFuturesV5ApiAccount.cs

@@ -0,0 +1,162 @@
+using HTX.Net.Enums;
+using HTX.Net.Interfaces.Clients.UsdtFuturesV5Api;
+using HTX.Net.Objects.Models.UsdtFuturesV5;
+
+namespace HTX.Net.Clients.UsdtFuturesV5
+{
+    /// <inheritdoc />
+    internal class HTXRestClientUsdtFuturesV5ApiAccount : IHTXRestClientUsdtFuturesV5ApiAccount
+    {
+        private static readonly RequestDefinitionCache _definitions = new RequestDefinitionCache();
+        private readonly HTXRestClientUsdtFuturesV5Api _baseClient;
+
+        internal HTXRestClientUsdtFuturesV5ApiAccount(HTXRestClientUsdtFuturesV5Api baseClient)
+        {
+            _baseClient = baseClient;
+        }
+
+        #region Get Asset Mode
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXAssetModeV5>> GetAssetModeAsync(CancellationToken ct = default)
+        {
+            var request = _definitions.GetOrCreate(HttpMethod.Get, "/v5/account/asset_mode", HTXExchange.RateLimiter.UsdtRead, 1, true);
+            return await _baseClient.SendAsync<HTXAssetModeV5>(request, null, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Set Asset Mode
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXAssetModeUpdateV5>> SetAssetModeAsync(AssetMode assetMode, CancellationToken ct = default)
+        {
+            var parameters = new ParameterCollection
+            {
+                { "assets_mode", EnumConverter.GetString(assetMode) }
+            };
+            var request = _definitions.GetOrCreate(HttpMethod.Post, "/v5/account/asset_mode", HTXExchange.RateLimiter.UsdtTrade, 1, true);
+            return await _baseClient.SendAsync<HTXAssetModeUpdateV5>(request, parameters, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Get Account Balance
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXAccountBalanceV5>> GetAccountBalanceAsync(CancellationToken ct = default)
+        {
+            var request = _definitions.GetOrCreate(HttpMethod.Get, "/v5/account/balance", HTXExchange.RateLimiter.UsdtRead, 1, true);
+            return await _baseClient.SendAsync<HTXAccountBalanceV5>(request, null, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Get Bills
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXBillV5[]>> GetBillsAsync(string? contractCode = null, MarginMode? marginMode = null, IEnumerable<FinancialRecordType>? types = null, DateTime? startTime = null, DateTime? endTime = null, long? fromId = null, int? limit = null, FilterDirection? direction = null, CancellationToken ct = default)
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalParameter("contract_code", contractCode);
+            parameters.AddOptionalEnum("margin_mode", marginMode);
+            parameters.AddOptionalParameter("type", types == null ? null : string.Join(",", types.Select(EnumConverter.GetString)));
+            parameters.AddOptionalMillisecondsString("start_time", startTime);
+            parameters.AddOptionalMillisecondsString("end_time", endTime);
+            parameters.AddOptionalParameter("from", fromId);
+            parameters.AddOptionalParameter("limit", limit);
+            parameters.AddOptionalEnum("direct", direction);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, "/v5/account/bills", HTXExchange.RateLimiter.UsdtRead, 1, true);
+            return await _baseClient.SendAsync<HTXBillV5[]>(request, parameters, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Get Position Mode
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXPositionModeV5>> GetPositionModeAsync(CancellationToken ct = default)
+        {
+            var request = _definitions.GetOrCreate(HttpMethod.Get, "/v5/position/mode", HTXExchange.RateLimiter.UsdtRead, 1, true);
+            return await _baseClient.SendAsync<HTXPositionModeV5>(request, null, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Set Position Mode
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXPositionModeV5>> SetPositionModeAsync(PositionMode positionMode, CancellationToken ct = default)
+        {
+            var parameters = new ParameterCollection
+            {
+                { "position_mode", EnumConverter.GetString(positionMode) }
+            };
+            var request = _definitions.GetOrCreate(HttpMethod.Post, "/v5/position/mode", HTXExchange.RateLimiter.UsdtTrade, 1, true);
+            return await _baseClient.SendAsync<HTXPositionModeV5>(request, parameters, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Get Leverage
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXLeverageV5[]>> GetLeverageAsync(string? contractCode = null, MarginMode? marginMode = null, FuturesPositionSide? positionSide = null, CancellationToken ct = default)
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalParameter("contract_code", contractCode);
+            parameters.AddOptionalEnum("margin_mode", marginMode);
+            parameters.AddOptionalEnum("position_side", positionSide);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, "/v5/position/lever", HTXExchange.RateLimiter.UsdtRead, 1, true);
+            return await _baseClient.SendAsync<HTXLeverageV5[]>(request, parameters, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Set Leverage
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXLeverageV5>> SetLeverageAsync(string contractCode, MarginMode marginMode, int leverageRate, FuturesPositionSide? positionSide = null, CancellationToken ct = default)
+        {
+            var parameters = new ParameterCollection
+            {
+                { "contract_code", contractCode },
+                { "lever_rate", leverageRate }
+            };
+            parameters.AddEnum("margin_mode", marginMode);
+            parameters.AddOptionalEnum("position_side", positionSide);
+            var request = _definitions.GetOrCreate(HttpMethod.Post, "/v5/position/lever", HTXExchange.RateLimiter.UsdtTrade, 1, true);
+            return await _baseClient.SendAsync<HTXLeverageV5>(request, parameters, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Get Open Positions
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXPositionV5[]>> GetOpenPositionsAsync(string? contractCode = null, CancellationToken ct = default)
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalParameter("contract_code", contractCode);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, "/v5/trade/position/opens", HTXExchange.RateLimiter.UsdtRead, 1, true);
+            return await _baseClient.SendAsync<HTXPositionV5[]>(request, parameters, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Get Risk Limits
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXPositionRiskLimitV5[]>> GetRiskLimitsAsync(string? contractCode = null, MarginMode? marginMode = null, FuturesPositionSide? positionSide = null, CancellationToken ct = default)
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalParameter("contract_code", contractCode);
+            parameters.AddOptionalEnum("margin_mode", marginMode);
+            parameters.AddOptionalEnum("position_side", positionSide);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, "/v5/position/risk/limit", HTXExchange.RateLimiter.UsdtRead, 1, true);
+            return await _baseClient.SendAsync<HTXPositionRiskLimitV5[]>(request, parameters, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+    }
+}

HTX.Net/Clients/UsdtFuturesV5/HTXRestClientUsdtFuturesV5ApiExchangeData.cs

@@ -0,0 +1,98 @@
+using HTX.Net.Enums;
+using HTX.Net.Interfaces.Clients.UsdtFuturesV5Api;
+using HTX.Net.Objects.Models.UsdtFuturesV5;
+
+namespace HTX.Net.Clients.UsdtFuturesV5
+{
+    /// <inheritdoc />
+    internal class HTXRestClientUsdtFuturesV5ApiExchangeData : IHTXRestClientUsdtFuturesV5ApiExchangeData
+    {
+        private static readonly RequestDefinitionCache _definitions = new RequestDefinitionCache();
+        private readonly HTXRestClientUsdtFuturesV5Api _baseClient;
+
+        internal HTXRestClientUsdtFuturesV5ApiExchangeData(HTXRestClientUsdtFuturesV5Api baseClient)
+        {
+            _baseClient = baseClient;
+        }
+
+        #region Get Funding Rate
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXFundingRateV5>> GetFundingRateAsync(string contractCode, CancellationToken ct = default)
+        {
+            var parameters = new ParameterCollection
+            {
+                { "contract_code", contractCode }
+            };
+            var request = _definitions.GetOrCreate(HttpMethod.Get, "/v5/market/funding_rate", HTXExchange.RateLimiter.UsdtRead, 1, false);
+            return await _baseClient.SendAsync<HTXFundingRateV5>(request, parameters, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Get Funding Rate History
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXFundingRateHistoryV5[]>> GetFundingRateHistoryAsync(string contractCode, DateTime? startTime = null, DateTime? endTime = null, long? fromId = null, int? limit = null, FilterDirection? direction = null, CancellationToken ct = default)
+        {
+            var parameters = new ParameterCollection
+            {
+                { "contract_code", contractCode }
+            };
+            parameters.AddOptionalMillisecondsString("start_time", startTime);
+            parameters.AddOptionalMillisecondsString("end_time", endTime);
+            parameters.AddOptionalParameter("from", fromId);
+            parameters.AddOptionalParameter("limit", limit);
+            parameters.AddOptionalEnum("direct", direction);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, "/v5/market/funding_rate_history", HTXExchange.RateLimiter.UsdtRead, 1, false);
+            return await _baseClient.SendAsync<HTXFundingRateHistoryV5[]>(request, parameters, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Get Open Interest
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXOpenInterestV5>> GetOpenInterestAsync(string contractCode, CancellationToken ct = default)
+        {
+            var parameters = new ParameterCollection
+            {
+                { "contract_code", contractCode }
+            };
+            var request = _definitions.GetOrCreate(HttpMethod.Get, "/v5/market/open_interest", HTXExchange.RateLimiter.UsdtRead, 1, false);
+            return await _baseClient.SendAsync<HTXOpenInterestV5>(request, parameters, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Get Price Limits
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXPriceLimitV5[]>> GetPriceLimitsAsync(string? contractCode = null, CancellationToken ct = default)
+        {
+            var parameters = new ParameterCollection();
+            parameters.AddOptionalParameter("contract_code", contractCode);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, "/v5/market/price_limit", HTXExchange.RateLimiter.UsdtRead, 1, false);
+            return await _baseClient.SendAsync<HTXPriceLimitV5[]>(request, parameters, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Get Risk Limits
+
+        /// <inheritdoc />
+        public async Task<WebCallResult<HTXRiskLimitV5[]>> GetRiskLimitsAsync(string contractCode, MarginMode? marginMode = null, string? tier = null, CancellationToken ct = default)
+        {
+            var parameters = new ParameterCollection
+            {
+                { "contract_code", contractCode }
+            };
+            parameters.AddOptionalEnum("margin_mode", marginMode);
+            parameters.AddOptionalParameter("tier", tier);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, "/v5/market/risk/limit", HTXExchange.RateLimiter.UsdtRead, 1, false);
+            return await _baseClient.SendAsync<HTXRiskLimitV5[]>(request, parameters, ct).ConfigureAwait(false);
+        }
+
+        #endregion
+    }
+}