/// <summary> /// Retrieve the candlestick charts of mark price. This endpoint can retrieve the latest 1,440 data entries. Charts are returned in groups based on the requested bar. /// </summary> /// <param name="instrumentId">Instrument ID</param> /// <param name="period">Bar size, the default is 1m</param> /// <param name="after">Pagination of data to return records earlier than the requested ts, Unix timestamp format in milliseconds, e.g. 1597026383085</param> /// <param name="before">Pagination of data to return records newer than the requested ts, Unix timestamp format in milliseconds, e.g. 1597026383085</param> /// <param name="limit">Number of results per request. The maximum is 100; the default is 100.</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <IEnumerable <OkexCandlestick> > > GetMarkPriceCandlesticks_Async(string instrumentId, OkexPeriod period, long?after = null, long?before = null, int limit = 100, CancellationToken ct = default) { if (limit < 1 || limit > 100) { throw new ArgumentException("Limit can be between 1-100."); } var parameters = new Dictionary <string, object> { { "instId", instrumentId }, { "bar", JsonConvert.SerializeObject(period, new PeriodConverter(false)) }, }; parameters.AddOptionalParameter("after", after?.ToString()); parameters.AddOptionalParameter("before", before?.ToString()); parameters.AddOptionalParameter("limit", limit.ToString()); var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexCandlestick> > >(GetUrl(Endpoints_V5_Market_MarkPriceCandles), HttpMethod.Get, ct, parameters).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <IEnumerable <OkexCandlestick> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <IEnumerable <OkexCandlestick> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } foreach (var candle in result.Data.Data) { candle.Instrument = instrumentId; } return(new WebCallResult <IEnumerable <OkexCandlestick> >(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// Retrieve the estimated delivery price, which will only have a return value one hour before the delivery/exercise. /// </summary> /// <param name="instrumentType">Instrument Type</param> /// <param name="underlying">Underlying</param> /// <param name="after">Pagination of data to return records earlier than the requested ts, Unix timestamp format in milliseconds, e.g. 1597026383085</param> /// <param name="before">Pagination of data to return records newer than the requested ts, Unix timestamp format in milliseconds, e.g. 1597026383085</param> /// <param name="limit">Number of results per request. The maximum is 100; the default is 100.</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <IEnumerable <OkexDeliveryExerciseHistory> > > GetDeliveryExerciseHistory_Async(OkexInstrumentType instrumentType, string underlying, long?after = null, long?before = null, int limit = 100, CancellationToken ct = default) { if (instrumentType.IsNotIn(OkexInstrumentType.Futures, OkexInstrumentType.Option)) { throw new ArgumentException("Instrument Type can be only Futures or Option."); } if (limit < 1 || limit > 100) { throw new ArgumentException("Limit can be between 1-100."); } var parameters = new Dictionary <string, object> { { "instType", JsonConvert.SerializeObject(instrumentType, new InstrumentTypeConverter(false)) }, { "uly", underlying }, }; parameters.AddOptionalParameter("after", after?.ToString()); parameters.AddOptionalParameter("before", before?.ToString()); parameters.AddOptionalParameter("limit", limit.ToString()); var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexDeliveryExerciseHistory> > >(GetUrl(Endpoints_V5_Public_DeliveryExerciseHistory), HttpMethod.Get, ct, parameters).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <IEnumerable <OkexDeliveryExerciseHistory> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <IEnumerable <OkexDeliveryExerciseHistory> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } return(new WebCallResult <IEnumerable <OkexDeliveryExerciseHistory> >(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// Retrieve a instrument is order book. /// </summary> /// <param name="instrumentId">Instrument ID</param> /// <param name="depth">Order book depth per side. Maximum 400, e.g. 400 bids + 400 asks. Default returns to 1 depth data</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <OkexOrderBook> > GetOrderBook_Async(string instrumentId, int depth = 1, CancellationToken ct = default) { if (depth < 1 || depth > 400) { throw new ArgumentException("Depth can be between 1-400."); } var parameters = new Dictionary <string, object> { { "instId", instrumentId }, { "sz", depth }, }; var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexOrderBook> > >(GetUrl(Endpoints_V5_Market_Books), HttpMethod.Get, ct, parameters).ConfigureAwait(false); if (!result.Success || result.Data.Data.Count() == 0) { return(WebCallResult <OkexOrderBook> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <OkexOrderBook> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } var orderbook = result.Data.Data.FirstOrDefault(); orderbook.Instrument = instrumentId; return(new WebCallResult <OkexOrderBook>(result.ResponseStatusCode, result.ResponseHeaders, orderbook, null)); }
/// <summary> /// Retrieve mark price. /// We set the mark price based on the SPOT index and at a reasonable basis to prevent individual users from manipulating the market and causing the contract price to fluctuate. /// </summary> /// <param name="instrumentType">Instrument Type</param> /// <param name="underlying">Underlying</param> /// <param name="instrumentId">Instrument ID</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <IEnumerable <OkexMarkPrice> > > GetMarkPrices_Async(OkexInstrumentType instrumentType, string underlying = null, string instrumentId = null, CancellationToken ct = default) { if (instrumentType.IsNotIn(OkexInstrumentType.Margin, OkexInstrumentType.Futures, OkexInstrumentType.Option, OkexInstrumentType.Swap)) { throw new ArgumentException("Instrument Type can be only Margin, Futures, Option or Swap."); } var parameters = new Dictionary <string, object> { { "instType", JsonConvert.SerializeObject(instrumentType, new InstrumentTypeConverter(false)) }, }; parameters.AddOptionalParameter("uly", underlying); parameters.AddOptionalParameter("instId", instrumentId); var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexMarkPrice> > >(GetUrl(Endpoints_V5_Public_MarkPrice), HttpMethod.Get, ct, parameters).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <IEnumerable <OkexMarkPrice> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <IEnumerable <OkexMarkPrice> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } return(new WebCallResult <IEnumerable <OkexMarkPrice> >(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// Used to make a withdrawal via Lightning. Maximum withdrawal amount is 0.1 BTC, minimum amount is 0.000001 BTC. Rolling 24 hour limit of 1 BTC. /// </summary> /// <param name="currency">Currency</param> /// <param name="invoice">Invoice text</param> /// <param name="password">fund password</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <OkexLightningWithdrawal> > GetLightningWithdrawals_Async( string currency, string invoice, string password, CancellationToken ct = default) { var parameters = new Dictionary <string, object> { { "ccy", currency }, { "invoice", invoice }, { "pwd", password }, }; var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexLightningWithdrawal> > >(GetUrl(Endpoints_V5_Asset_WithdrawalLightning), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <OkexLightningWithdrawal> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <OkexLightningWithdrawal> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } return(new WebCallResult <OkexLightningWithdrawal>(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data.FirstOrDefault(), null)); }
/// <summary> /// only 100 invoices can be generated within a 24 hour period. /// </summary> /// <param name="currency">Currency</param> /// <param name="amount">deposit amount between 0.000001 - 0.1</param> /// <param name="account">Receiving account</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <IEnumerable <OkexLightningDeposit> > > GetLightningDeposits_Async( string currency, decimal amount, OkexLightningDepositAccount?account = null, CancellationToken ct = default) { var parameters = new Dictionary <string, object> { { "ccy", currency }, { "amt", amount.ToString(OkexGlobals.OkexCultureInfo) }, }; if (account.HasValue) { parameters.AddOptionalParameter("to", JsonConvert.SerializeObject(account, new LightningDepositAccountConverter(false))); } var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexLightningDeposit> > >(GetUrl(Endpoints_V5_Asset_DepositLightning), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <IEnumerable <OkexLightningDeposit> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <IEnumerable <OkexLightningDeposit> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } return(new WebCallResult <IEnumerable <OkexLightningDeposit> >(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// Retrieve the recent transactions of an instrument. /// </summary> /// <param name="instrumentId">Instrument ID</param> /// <param name="limit">Number of results per request. The maximum is 100; the default is 100.</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <IEnumerable <OkexTrade> > > GetTrades_Async(string instrumentId, int limit = 100, CancellationToken ct = default) { if (limit < 1 || limit > 500) { throw new ArgumentException("Limit can be between 1-500."); } var parameters = new Dictionary <string, object> { { "instId", instrumentId }, }; parameters.AddOptionalParameter("limit", limit.ToString()); var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexTrade> > >(GetUrl(Endpoints_V5_Market_Trades), HttpMethod.Get, ct, parameters).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <IEnumerable <OkexTrade> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <IEnumerable <OkexTrade> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } return(new WebCallResult <IEnumerable <OkexTrade> >(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// applies to master accounts only /// </summary> /// <param name="password">Funds password of the master account</param> /// <param name="subAccountName">Sub Account Name</param> /// <param name="apiKey">API public key</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <OkexSubAccountName> > DeleteSubAccountApiKey_Async( string password, string subAccountName, string apiKey, CancellationToken ct = default) { var parameters = new Dictionary <string, object> { { "pwd", password }, { "subAcct", subAccountName }, { "apiKey", apiKey }, }; var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexSubAccountName> > >(GetUrl(Endpoints_V5_SubAccount_DeleteApiKey), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <OkexSubAccountName> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <OkexSubAccountName> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } return(new WebCallResult <OkexSubAccountName>(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data.FirstOrDefault(), null)); }
/// <summary> /// Gets the withdrawal history /// </summary> /// <param name="asset">Filter by asset</param> /// <param name="status">Filter by status</param> /// <param name="startTime">Filter start time from</param> /// <param name="endTime">Filter end time till</param> /// <param name="receiveWindow">The receive window for which this request is active. When the request takes longer than this to complete the server will reject the request</param> /// <param name="ct">Cancellation token</param> /// <returns>List of withdrawals</returns> public async Task <WebCallResult <IEnumerable <BinanceWithdrawal> > > GetWithdrawalHistoryAsync(string?asset = null, WithdrawalStatus?status = null, DateTime?startTime = null, DateTime?endTime = null, int?receiveWindow = null, CancellationToken ct = default) { var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false); if (!timestampResult) { return(new WebCallResult <IEnumerable <BinanceWithdrawal> >(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error)); } var parameters = new Dictionary <string, object> { { "timestamp", _baseClient.GetTimestamp() } }; parameters.AddOptionalParameter("asset", asset); parameters.AddOptionalParameter("status", status != null ? JsonConvert.SerializeObject(status, new WithdrawalStatusConverter(false)) : null); parameters.AddOptionalParameter("startTime", startTime != null ? BinanceClient.ToUnixTimestamp(startTime.Value).ToString(CultureInfo.InvariantCulture) : null); parameters.AddOptionalParameter("endTime", endTime != null ? BinanceClient.ToUnixTimestamp(endTime.Value).ToString(CultureInfo.InvariantCulture) : null); parameters.AddOptionalParameter("recvWindow", receiveWindow?.ToString(CultureInfo.InvariantCulture) ?? _baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture)); var result = await _baseClient.SendRequestInternal <BinanceWithdrawalList>(_baseClient.GetUrlSpot(withdrawHistoryEndpoint, "wapi", "3"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false); if (!result || result.Data == null) { return(WebCallResult <IEnumerable <BinanceWithdrawal> > .CreateErrorResult(result.Error ?? new UnknownError("Unknown response"))); } if (!result.Data.Success) { return(new WebCallResult <IEnumerable <BinanceWithdrawal> >(result.ResponseStatusCode, result.ResponseHeaders, null, _baseClient.ParseErrorResponseInternal(result.Data.Message))); } return(new WebCallResult <IEnumerable <BinanceWithdrawal> >(result.ResponseStatusCode, result.ResponseHeaders, result.Data.List, null)); }
/// <summary> /// Cancel Hashrate Resale Configuration /// </summary> /// <param name="configId">Mining id</param> /// <param name="userName">Mining account</param> /// <param name="ct">Resale hashrate h/s must be transferred (BTC is greater than 500000000000 ETH is greater than 500000)</param> /// <returns>Success</returns> public async Task <WebCallResult <bool> > PlaceHashrateResaleRequest(int configId, string userName, CancellationToken ct = default) { userName.ValidateNotNull(nameof(userName)); var parameters = new Dictionary <string, object>() { { "configId", configId }, { "userName", userName }, { "timestamp", _baseClient.GetTimestamp() } }; var result = await _baseClient.SendRequestInternal <BinanceResult <bool> >(_baseClient.GetUrlSpot(miningHashrateResaleCancel, "sapi", "1"), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <bool> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error !)); } if (result.Data?.Code != 0) { return(WebCallResult <bool> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data !.Code, result.Data.Message))); } return(new WebCallResult <bool>(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// This is the taker volume for both buyers and sellers. This shows the influx and exit of funds in and out of {coin}. /// </summary> /// <param name="currency">Currency</param> /// <param name="instrumentType">Instrument Type</param> /// <param name="period">period, the default is 5m, e.g. [5m/1H/1D]</param> /// <param name="begin">begin, e.g. 1597026383085</param> /// <param name="end">end, e.g. 1597026383011</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <IEnumerable <OkexTakerVolume> > > GetRubikTakerVolume_Async( string currency, OkexInstrumentType instrumentType, OkexPeriod period = OkexPeriod.FiveMinutes, long?begin = null, long?end = null, CancellationToken ct = default) { var parameters = new Dictionary <string, object> { { "ccy", currency }, { "instType", JsonConvert.SerializeObject(instrumentType, new InstrumentTypeConverter(false)) }, { "period", JsonConvert.SerializeObject(period, new PeriodConverter(false)) }, }; parameters.AddOptionalParameter("begin", begin?.ToString(OkexGlobals.OkexCultureInfo)); parameters.AddOptionalParameter("end", end?.ToString(OkexGlobals.OkexCultureInfo)); var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexTakerVolume> > >(GetUrl(Endpoints_V5_RubikStat_TakerVolume), HttpMethod.Get, ct, parameters).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <IEnumerable <OkexTakerVolume> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <IEnumerable <OkexTakerVolume> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } return(new WebCallResult <IEnumerable <OkexTakerVolume> >(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// Withdrawal of tokens. /// </summary> /// <param name="currency">Currency</param> /// <param name="amount">Amount</param> /// <param name="destination">Withdrawal destination address</param> /// <param name="toAddress">Verified digital currency address, email or mobile number. Some digital currency addresses are formatted as 'address+tag', e.g. 'ARDOR-7JF3-8F2E-QUWZ-CAN7F:123456'</param> /// <param name="password">Trade password</param> /// <param name="fee">Transaction fee</param> /// <param name="chain">Chain name. There are multiple chains under some currencies, such as USDT has USDT-ERC20, USDT-TRC20, and USDT-Omni. If this parameter is not filled in because it is not available, it will default to the main chain.</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <OkexWithdrawalResponse> > Withdraw_Async( string currency, decimal amount, OkexWithdrawalDestination destination, string toAddress, string password, decimal fee, string chain = null, CancellationToken ct = default) { var parameters = new Dictionary <string, object> { { "ccy", currency }, { "amt", amount.ToString(OkexGlobals.OkexCultureInfo) }, { "dest", JsonConvert.SerializeObject(destination, new WithdrawalDestinationConverter(false)) }, { "toAddr", toAddress }, { "pwd", password }, { "fee", fee.ToString(OkexGlobals.OkexCultureInfo) }, }; parameters.AddOptionalParameter("chain", chain); var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexWithdrawalResponse> > >(GetUrl(Endpoints_V5_Asset_Withdrawal), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <OkexWithdrawalResponse> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <OkexWithdrawalResponse> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } return(new WebCallResult <OkexWithdrawalResponse>(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data.FirstOrDefault(), null)); }
/// <summary> /// Places an order /// </summary> /// <param name="accountId">The account to place the order for</param> /// <param name="symbol">The symbol to place the order for</param> /// <param name="orderType">The type of the order</param> /// <param name="amount">The amount of the order</param> /// <param name="price">The price of the order. Should be omitted for market orders</param> /// <returns></returns> public async Task <WebCallResult <long> > PlaceOrderAsync(long accountId, string symbol, HuobiOrderType orderType, decimal amount, decimal?price = null) { if (orderType == HuobiOrderType.StopLimitBuy || orderType == HuobiOrderType.StopLimitSell) { return(WebCallResult <long> .CreateErrorResult(new ArgumentError("Stop limit orders not supported by API"))); } var parameters = new Dictionary <string, object> { { "account-id", accountId }, { "amount", amount }, { "symbol", symbol }, { "type", JsonConvert.SerializeObject(orderType, new OrderTypeConverter(false)) } }; // If precision of the symbol = 1 (eg has to use whole amounts, 1,2,3 etc) Huobi doesn't except the .0 postfix (1.0) for amount // Issue at the Huobi side if (amount % 1 == 0) { parameters["amount"] = amount.ToString(CultureInfo.InvariantCulture); } parameters.AddOptionalParameter("price", price); var result = await ExecuteRequest <HuobiBasicResponse <long> >(GetUrl(PlaceOrderEndpoint, "1"), "POST", parameters, true).ConfigureAwait(false); return(new WebCallResult <long>(result.ResponseStatusCode, result.ResponseHeaders, result.Data?.Data ?? 0, result.Error)); }
/// <summary> /// Gets miner list /// </summary> /// <param name="algorithm">Algorithm</param> /// <param name="userName">Mining account</param> /// <param name="page">Result page</param> /// <param name="sortAscending">Sort in ascending order</param> /// <param name="sortColumn">Column to sort by</param> /// <param name="workerStatus">Filter by status</param> /// <param name="ct">Cancellation token</param> /// <returns>Miner list</returns> public async Task <WebCallResult <BinanceMinerList> > GetMinerListAsync(string algorithm, string userName, int?page = null, bool?sortAscending = null, string?sortColumn = null, MinerStatus?workerStatus = null, CancellationToken ct = default) { algorithm.ValidateNotNull(nameof(algorithm)); userName.ValidateNotNull(nameof(userName)); var parameters = new Dictionary <string, object>() { { "algo", algorithm }, { "userName", userName }, }; parameters.AddOptionalParameter("page", page?.ToString(CultureInfo.InvariantCulture)); parameters.AddOptionalParameter("sortAscending", sortAscending == null ? null : sortAscending == true ? "1" : "0"); parameters.AddOptionalParameter("sortColumn", sortColumn); parameters.AddOptionalParameter("workerStatus", workerStatus == null ? null : JsonConvert.SerializeObject(workerStatus, new MinerStatusConverter(false))); var result = await _baseClient.SendRequestInternal <BinanceResult <BinanceMinerList> >(_baseClient.GetUrlSpot(minerListEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <BinanceMinerList> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error !)); } if (result.Data?.Code != 0) { return(WebCallResult <BinanceMinerList> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data !.Code, result.Data.Message))); } return(new WebCallResult <BinanceMinerList>(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// Gets hash rate resale details /// </summary> /// <param name="configId">The mining id</param> /// <param name="userName">Mining account</param> /// <param name="page">Page</param> /// <param name="pageSize">Results per page</param> /// <param name="ct">Cancellation token</param> /// <returns>Resale details</returns> public async Task <WebCallResult <BinanceHashrateResaleDetails> > GetHashrateResaleDetailsAsync(int configId, string userName, int?page = null, int?pageSize = null, CancellationToken ct = default) { userName.ValidateNotNull(nameof(userName)); var parameters = new Dictionary <string, object>() { { "configId", configId.ToString(CultureInfo.InvariantCulture) }, { "userName", userName } }; parameters.AddOptionalParameter("pageIndex", page?.ToString(CultureInfo.InvariantCulture)); parameters.AddOptionalParameter("pageSize", pageSize?.ToString(CultureInfo.InvariantCulture)); var result = await _baseClient.SendRequestInternal <BinanceResult <BinanceHashrateResaleDetails> >(_baseClient.GetUrlSpot(miningHashrateResaleDetailsEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <BinanceHashrateResaleDetails> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error !)); } if (result.Data?.Code != 0) { return(WebCallResult <BinanceHashrateResaleDetails> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data !.Code, result.Data.Message))); } return(new WebCallResult <BinanceHashrateResaleDetails>(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// Gets mining account list /// </summary> /// <param name="algorithm">Algorithm</param> /// <param name="userName">Mining account user name</param> /// <param name="ct">Cancellation token</param> /// <returns>Revenue list</returns> public async Task <WebCallResult <BinanceMiningAccount> > GetMiningAccountListAsync(string algorithm, string userName, CancellationToken ct = default) { algorithm.ValidateNotNull(nameof(algorithm)); userName.ValidateNotNull(nameof(userName)); var parameters = new Dictionary <string, object>() { { "algo", algorithm }, { "userName", userName }, }; var result = await _baseClient.SendRequestInternal <BinanceResult <BinanceMiningAccount> >(_baseClient.GetUrlSpot(miningAccountListEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <BinanceMiningAccount> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error !)); } if (result.Data?.Code != 0) { return(WebCallResult <BinanceMiningAccount> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data !.Code, result.Data.Message))); } return(new WebCallResult <BinanceMiningAccount>(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// applies to master accounts only /// </summary> /// <param name="enable">Sub-account status,true: Normal ; false: Frozen</param> /// <param name="subAccountName">Sub Account Name</param> /// <param name="after">Pagination of data to return records earlier than the requested ts, Unix timestamp format in milliseconds, e.g. 1597026383085</param> /// <param name="before">Pagination of data to return records newer than the requested ts, Unix timestamp format in milliseconds, e.g. 1597026383085</param> /// <param name="limit">Number of results per request. The maximum is 100; the default is 100.</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <IEnumerable <OkexSubAccount> > > GetSubAccounts_Async( bool?enable = null, string subAccountName = null, long?after = null, long?before = null, int limit = 100, CancellationToken ct = default) { if (limit < 1 || limit > 100) { throw new ArgumentException("Limit can be between 1-100."); } var parameters = new Dictionary <string, object>(); parameters.AddOptionalParameter("enable", enable); parameters.AddOptionalParameter("subAcct", subAccountName); parameters.AddOptionalParameter("after", after?.ToString(OkexGlobals.OkexCultureInfo)); parameters.AddOptionalParameter("before", before?.ToString(OkexGlobals.OkexCultureInfo)); parameters.AddOptionalParameter("limit", limit.ToString(OkexGlobals.OkexCultureInfo)); var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexSubAccount> > >(GetUrl(Endpoints_V5_SubAccount_List), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <IEnumerable <OkexSubAccount> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <IEnumerable <OkexSubAccount> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } return(new WebCallResult <IEnumerable <OkexSubAccount> >(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// Hashrate resale request /// </summary> /// <param name="userName">Mining account</param> /// <param name="algorithm">Transfer algorithm</param> /// <param name="startDate">Resale start time</param> /// <param name="endDate">Resale end time</param> /// <param name="toUser">To mining account</param> /// <param name="hashRate">Results per page</param> /// <param name="ct">Resale hashrate h/s must be transferred (BTC is greater than 500000000000 ETH is greater than 500000)</param> /// <returns>Mining account</returns> public async Task <WebCallResult <int> > PlaceHashrateResaleRequest(string userName, string algorithm, DateTime startDate, DateTime endDate, string toUser, decimal hashRate, CancellationToken ct = default) { userName.ValidateNotNull(nameof(userName)); algorithm.ValidateNotNull(nameof(algorithm)); toUser.ValidateNotNull(nameof(toUser)); var parameters = new Dictionary <string, object>() { { "userName", userName }, { "algo", algorithm }, { "startDate", JsonConvert.SerializeObject(startDate, new TimestampConverter()) }, { "endDate", JsonConvert.SerializeObject(endDate, new TimestampConverter()) }, { "toPoolUser", toUser }, { "hashRate", hashRate }, }; var result = await _baseClient.SendRequestInternal <BinanceResult <int> >(_baseClient.GetUrlSpot(miningHashrateResaleRequest, "sapi", "1"), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <int> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error !)); } if (result.Data?.Code != 0) { return(WebCallResult <int> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data !.Code, result.Data.Message))); } return(new WebCallResult <int>(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// This shows what option strikes are the most popular for each expiration. /// </summary> /// <param name="currency">Currency</param> /// <param name="expiryTime">expiry time (Format: YYYYMMdd, for example: "20210623")</param> /// <param name="period">period, the default is 8H. e.g. [8H/1D]</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <IEnumerable <OkexInterestVolumeStrike> > > GetRubikInterestVolumeStrike_Async( string currency, string expiryTime, OkexPeriod period = OkexPeriod.FiveMinutes, CancellationToken ct = default) { var parameters = new Dictionary <string, object> { { "ccy", currency }, { "expTime", expiryTime }, { "period", JsonConvert.SerializeObject(period, new PeriodConverter(false)) }, }; var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexInterestVolumeStrike> > >(GetUrl(Endpoints_V5_RubikStat_OptionOpenInterestVolumeStrike), HttpMethod.Get, ct, parameters).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <IEnumerable <OkexInterestVolumeStrike> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <IEnumerable <OkexInterestVolumeStrike> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } return(new WebCallResult <IEnumerable <OkexInterestVolumeStrike> >(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// applies to master accounts only /// </summary> /// <param name="currency">Currency</param> /// <param name="amount">Amount</param> /// <param name="fromAccount">6:Funding Account 18:Unified Account</param> /// <param name="toAccount">6:Funding Account 18:Unified Account</param> /// <param name="fromSubAccountName">Sub-account name of the account that transfers funds out.</param> /// <param name="toSubAccountName">Sub-account name of the account that transfers funds in.</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <OkexSubAccountTransfer> > TransferBetweenSubAccounts_Async( string currency, decimal amount, OkexAccount fromAccount, OkexAccount toAccount, string fromSubAccountName, string toSubAccountName, CancellationToken ct = default) { var parameters = new Dictionary <string, object> { { "ccy", currency }, { "amt", amount.ToString(OkexGlobals.OkexCultureInfo) }, { "from", JsonConvert.SerializeObject(fromAccount, new AccountConverter(false)) }, { "to", JsonConvert.SerializeObject(toAccount, new AccountConverter(false)) }, { "fromSubAccount", fromSubAccountName }, { "toSubAccount", toSubAccountName }, }; var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexSubAccountTransfer> > >(GetUrl(Endpoints_V5_SubAccount_Transfer), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <OkexSubAccountTransfer> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <OkexSubAccountTransfer> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } return(new WebCallResult <OkexSubAccountTransfer>(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data.FirstOrDefault(), null)); }
/// <summary> /// PiggyBank Purchase/Redemption /// </summary> /// <param name="currency">Currency</param> /// <param name="amount">Amount</param> /// <param name="side">Side</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <OkexPiggyBankActionResponse> > PiggyBankAction_Async( string currency, decimal amount, OkexPiggyBankActionSide side, CancellationToken ct = default) { var parameters = new Dictionary <string, object> { { "ccy", currency }, { "amt", amount.ToString(OkexGlobals.OkexCultureInfo) }, { "side", JsonConvert.SerializeObject(side, new PiggyBankActionSideConverter(false)) }, }; var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexPiggyBankActionResponse> > >(GetUrl(Endpoints_V5_Asset_PurchaseRedempt), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <OkexPiggyBankActionResponse> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <OkexPiggyBankActionResponse> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } return(new WebCallResult <OkexPiggyBankActionResponse>(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data.FirstOrDefault(), null)); }
/// <summary> /// applies to master accounts only /// </summary> /// <param name="password">Funds password of the master account</param> /// <param name="subAccountName">Sub Account Name</param> /// <param name="apiKey">APIKey note</param> /// <param name="apiLabel">APIKey note</param> /// <param name="permission">APIKey access</param> /// <param name="ipAddresses">Link IP addresses, separate with commas if more than one. Support up to 20 IP addresses.</param> /// <param name="ct">Cancellation Token</param> /// <returns></returns> public virtual async Task <WebCallResult <OkexSubAccountApiKey> > ModifySubAccountApiKey_Async( string password, string subAccountName, string apiKey, string apiLabel, OkexApiPermission permission, string ipAddresses = null, CancellationToken ct = default) { var parameters = new Dictionary <string, object> { { "pwd", password }, { "subAcct", subAccountName }, { "label", apiLabel }, { "apiKey", apiKey }, { "perm", JsonConvert.SerializeObject(permission, new ApiPermissionConverter(false)) }, }; parameters.AddOptionalParameter("ip", ipAddresses); var result = await SendRequestAsync <OkexRestApiResponse <IEnumerable <OkexSubAccountApiKey> > >(GetUrl(Endpoints_V5_SubAccount_ModifyApiKey), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <OkexSubAccountApiKey> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } if (result.Data.ErrorCode > 0) { return(WebCallResult <OkexSubAccountApiKey> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data.ErrorCode, result.Data.ErrorMessage, result.Data.Data))); } return(new WebCallResult <OkexSubAccountApiKey>(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data.FirstOrDefault(), null)); }
/// <summary> /// Get other revenue list /// </summary> /// <param name="algorithm">Algorithm</param> /// <param name="userName">Mining account</param> /// <param name="page">Result page</param> /// <param name="pageSize">Results per page</param> /// <param name="coin">Coin</param> /// <param name="startDate">Start date</param> /// <param name="endDate">End date</param> /// <param name="ct">Cancellation token</param> /// <returns>Revenue list</returns> public async Task <WebCallResult <BinanceOtherRevenueList> > GetMiningOtherRevenueListAsync(string algorithm, string userName, string?coin = null, DateTime?startDate = null, DateTime?endDate = null, int?page = null, int?pageSize = null, CancellationToken ct = default) { algorithm.ValidateNotNull(nameof(algorithm)); userName.ValidateNotNull(nameof(userName)); var parameters = new Dictionary <string, object>() { { "algo", algorithm }, { "userName", userName }, }; parameters.AddOptionalParameter("page", page?.ToString(CultureInfo.InvariantCulture)); parameters.AddOptionalParameter("pageSize", pageSize?.ToString(CultureInfo.InvariantCulture)); parameters.AddOptionalParameter("coin", coin); parameters.AddOptionalParameter("startDate", startDate.HasValue ? JsonConvert.SerializeObject(startDate.Value, new TimestampConverter()) : null); parameters.AddOptionalParameter("endDate", endDate.HasValue ? JsonConvert.SerializeObject(endDate.Value, new TimestampConverter()) : null); var result = await _baseClient.SendRequestInternal <BinanceResult <BinanceOtherRevenueList> >(_baseClient.GetUrlSpot(miningOtherRevenueEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <BinanceOtherRevenueList> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error !)); } if (result.Data?.Code != 0) { return(WebCallResult <BinanceOtherRevenueList> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data !.Code, result.Data.Message))); } return(new WebCallResult <BinanceOtherRevenueList>(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// Gets the market depth for a symbol /// </summary> /// <param name="symbol">The symbol to request for</param> /// <param name="mergeStep">The way the results will be merged together</param> /// <param name="limit">The depth of the book</param> /// <returns></returns> public async Task <WebCallResult <HuobiMarketDepth> > GetMarketDepthAsync(string symbol, int mergeStep, int?limit = null) { if (mergeStep < 0 || mergeStep > 5) { return(WebCallResult <HuobiMarketDepth> .CreateErrorResult(new ArgumentError("MergeStep should be between 0 and 5"))); } if (limit.HasValue && limit != 5 && limit != 10 && limit != 20) { return(WebCallResult <HuobiMarketDepth> .CreateErrorResult(new ArgumentError("Limit should be one of: 5, 10, 20"))); } var parameters = new Dictionary <string, object> { { "symbol", symbol }, { "type", "step" + mergeStep } }; parameters.AddOptionalParameter("depth", limit); var result = await ExecuteRequest <HuobiChannelResponse <HuobiMarketDepth> >(GetUrl(MarketDepthEndpoint), parameters : parameters, checkResult : false).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <HuobiMarketDepth> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } result.Data.Data.Timestamp = result.Data.Timestamp; return(new WebCallResult <HuobiMarketDepth>(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
private WebCallResult <T> EvaluateError <T>(Error error) { if (ThrowThenErrorResponse) { throw new BitGoErrorException(error); } return(WebCallResult <T> .CreateErrorResult(error)); }
private static WebCallResult <T> GetResult <T>(WebCallResult <CoinExApiResult <T> > result) where T : class { if (result.Error != null || result.Data == null) { return(WebCallResult <T> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } return(new WebCallResult <T>(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data, null)); }
/// <summary> /// Get the server time /// </summary> /// <returns>Server time</returns> public async Task <CallResult <DateTime> > GetServerTimeAsync() { var result = await Execute <KrakenServerTime>(GetUri("/0/public/Time")).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <DateTime> .CreateErrorResult(result.Error)); } return(new CallResult <DateTime>(result.Data.UnixTime, null)); }
private static WebCallResult <T> GetResult <T>(WebCallResult <BittrexApiResult <T> > result) where T : class { if (result.Error != null || result.Data == null) { return(WebCallResult <T> .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } var messageEmpty = string.IsNullOrEmpty(result.Data.Message); return(new WebCallResult <T>(result.ResponseStatusCode, result.ResponseHeaders, !messageEmpty ? null: result.Data.Result, !messageEmpty ? new ServerError(result.Data.Message): null)); }
async Task <WebCallResult <IEnumerable <ICommonRecentTrade> > > IExchangeClient.GetRecentTradesAsync(string symbol) { var tradesResult = await GetTradeHistoryAsync(symbol, null).ConfigureAwait(false); if (!tradesResult.Success) { return(WebCallResult <IEnumerable <ICommonRecentTrade> > .CreateErrorResult(tradesResult.ResponseStatusCode, tradesResult.ResponseHeaders, tradesResult.Error !)); } return(tradesResult.As <IEnumerable <ICommonRecentTrade> >(tradesResult.Data?.Data)); }
/// <summary> /// Gets a list of balances for a specific sub account /// </summary> /// <param name="subAccountId">The id of the sub account to get the balances for</param> /// <returns></returns> public async Task <WebCallResult <List <HuobiBalance> > > GetSubAccountBalancesAsync(long subAccountId) { var result = await ExecuteRequest <HuobiBasicResponse <List <HuobiAccountBalances> > >(GetUrl(FillPathParameter(GetSubAccountBalancesEndpoint, subAccountId.ToString()), "1"), signed : true).ConfigureAwait(false); if (!result.Success) { return(WebCallResult <List <HuobiBalance> > .CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error)); } return(new WebCallResult <List <HuobiBalance> >(result.ResponseStatusCode, result.ResponseHeaders, result.Data.Data[0].Data, result.Error)); }