/// <summary>
/// Gets a list of trades for a specific symbol
/// </summary>
/// <param name="symbol">The symbol to retrieve trades for</param>
/// <param name="types">The type of orders to return</param>
/// <param name="startTime">Only get orders after this date</param>
/// <param name="endTime">Only get orders before this date</param>
/// <param name="fromId">Only get orders with id's higher than this</param>
/// <param name="limit">The max number of results</param>
/// <returns></returns>
public async Task <WebCallResult <List <HuobiOrderTrade> > > GetSymbolTradesAsync(string symbol, IEnumerable <HuobiOrderType> types = null, DateTime?startTime = null, DateTime?endTime = null, long?fromId = null, int?limit = null)
{
var typeConverter = new OrderTypeConverter(false);
var parameters = new Dictionary <string, object>
{
{ "symbol", symbol }
};
parameters.AddOptionalParameter("start-date", startTime?.ToString("yyyy-MM-dd"));
parameters.AddOptionalParameter("end-date", endTime?.ToString("yyyy-MM-dd"));
parameters.AddOptionalParameter("types", types == null ? null : string.Join(",", types.Select(s => JsonConvert.SerializeObject(s, typeConverter))));
parameters.AddOptionalParameter("from", fromId);
parameters.AddOptionalParameter("size", limit);
var result = await ExecuteRequest <HuobiBasicResponse <List <HuobiOrderTrade> > >(GetUrl(SymbolTradesEndpoint, "1"), "GET", parameters, true).ConfigureAwait(false);
return(new WebCallResult <List <HuobiOrderTrade> >(result.ResponseStatusCode, result.ResponseHeaders, result.Data?.Data, result.Error));
}
/// <summary>
/// Gets a list of trades for a specific symbol
/// </summary>
/// <param name="states">Only return trades with specific states</param>
/// <param name="symbol">The symbol to retrieve trades for</param>
/// <param name="types">The type of orders to return</param>
/// <param name="startTime">Only get orders after this date</param>
/// <param name="endTime">Only get orders before this date</param>
/// <param name="fromId">Only get orders with before or after this. Used together with the direction parameter</param>
/// <param name="direction">Direction of the results to return when using the fromId parameter</param>
/// <param name="limit">The max number of results</param>
/// <param name="ct">Cancellation token</param>
/// <returns></returns>
public async Task <WebCallResult <IEnumerable <HuobiOrderTrade> > > GetSymbolTradesAsync(IEnumerable <HuobiOrderState>?states = null, string?symbol = null, IEnumerable <HuobiOrderType>?types = null, DateTime?startTime = null, DateTime?endTime = null, long?fromId = null, HuobiFilterDirection?direction = null, int?limit = null, CancellationToken ct = default)
{
symbol = symbol?.ValidateHuobiSymbol();
var stateConverter = new OrderStateConverter(false);
var typeConverter = new OrderTypeConverter(false);
var parameters = new Dictionary <string, object>();
parameters.AddOptionalParameter("states", states == null ? null : string.Join(",", states.Select(s => JsonConvert.SerializeObject(s, stateConverter))));
parameters.AddOptionalParameter("symbol", symbol);
parameters.AddOptionalParameter("start-date", startTime?.ToString("yyyy-MM-dd"));
parameters.AddOptionalParameter("end-date", endTime?.ToString("yyyy-MM-dd"));
parameters.AddOptionalParameter("types", types == null ? null : string.Join(",", types.Select(s => JsonConvert.SerializeObject(s, typeConverter))));
parameters.AddOptionalParameter("from", fromId);
parameters.AddOptionalParameter("direct", direction == null ? null : JsonConvert.SerializeObject(direction, new FilterDirectionConverter(false)));
parameters.AddOptionalParameter("size", limit);
return(await SendHuobiRequest <IEnumerable <HuobiOrderTrade> >(GetUrl(SymbolTradesEndpoint, "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false));
}
public override Order Parse(JToken token)
{
TokenNotNull(token);
var order = new Order
{
Quantity = token.Value <int>("quantity"),
Type = OrderTypeConverter.FromString(token.Value <string>("order_type")),
Plat = token.Value <int>("platinum"),
User = Parse <User>(token["user"]),
Platform = PlatformTypeConverter.FromString(token.Value <string>("platform")),
Region = token.Value <string>("region"),
CreatedDate = token.Value <DateTime>("creation_date"),
LastUpdate = token.Value <DateTime>("last_update"),
IsVisible = token.Value <bool>("visible"),
Id = token.Value <string>("id")
};
return(order);
}
/// <summary>
/// Gets a list of orders
/// </summary>
/// <param name="accountId">The account id to get orders for</param>
/// <param name="symbol">The symbol to get orders for</param>
/// <param name="states">The states of orders to return</param>
/// <param name="types">The types of orders to return</param>
/// <param name="startTime">Only get orders after this date</param>
/// <param name="endTime">Only get orders before this date</param>
/// <param name="fromId">Only get orders with id's higher than this</param>
/// <param name="limit">The max number of results</param>
/// <returns></returns>
public async Task <CallResult <List <HuobiOrder> > > QueryOrdersAsync(long accountId, string symbol, HuobiOrderState[] states, HuobiOrderType[] types = null, DateTime?startTime = null, DateTime?endTime = null, long?fromId = null, int?limit = null)
{
var stateConverter = new OrderStateConverter(false);
var stateString = string.Join(",", states.Select(s => JsonConvert.SerializeObject(s, stateConverter)));
var request = new HuobiOrderListRequest(accountId, symbol, stateString);
if (types != null)
{
var typeConverter = new OrderTypeConverter(false);
request.Types = string.Join(",", types.Select(s => JsonConvert.SerializeObject(s, typeConverter)));
}
request.StartTime = startTime?.ToString("yyyy-MM-dd");
request.EndTime = endTime?.ToString("yyyy-MM-dd");
request.FromId = fromId?.ToString();
request.Limit = limit?.ToString();
var result = await Query <HuobiSocketAuthDataResponse <List <HuobiOrder> > >(request).ConfigureAwait(false);
return(new CallResult <List <HuobiOrder> >(result.Data?.Data, result.Error));
}
/// <summary>
/// Gets a list of orders
/// </summary>
/// <param name="accountId">The account id to get orders for</param>
/// <param name="symbol">The symbol to get orders for</param>
/// <param name="states">The states of orders to return</param>
/// <param name="types">The types of orders to return</param>
/// <param name="startTime">Only get orders after this date</param>
/// <param name="endTime">Only get orders before this date</param>
/// <param name="fromId">Only get orders with id's higher than this</param>
/// <param name="limit">The max number of results</param>
/// <returns></returns>
public async Task <CallResult <IEnumerable <HuobiOrder> > > GetOrdersAsync(long accountId, string symbol, IEnumerable <HuobiOrderState> states, IEnumerable <HuobiOrderType>?types = null, DateTime?startTime = null, DateTime?endTime = null, long?fromId = null, int?limit = null)
{
symbol = symbol.ValidateHuobiSymbol();
var stateConverter = new OrderStateConverter(false);
var stateString = string.Join(",", states.Select(s => JsonConvert.SerializeObject(s, stateConverter)));
var request = new HuobiOrderListRequest(NextId().ToString(CultureInfo.InvariantCulture), accountId, symbol, stateString);
if (types != null)
{
var typeConverter = new OrderTypeConverter(false);
request.Types = string.Join(",", types.Select(s => JsonConvert.SerializeObject(s, typeConverter)));
}
request.StartTime = startTime?.ToString("yyyy-MM-dd");
request.EndTime = endTime?.ToString("yyyy-MM-dd");
request.FromId = fromId?.ToString(CultureInfo.InvariantCulture);
request.Limit = limit?.ToString(CultureInfo.InvariantCulture);
var result = await Query <HuobiSocketAuthDataResponse <IEnumerable <HuobiOrder> > >(request, true).ConfigureAwait(false);
return(new CallResult <IEnumerable <HuobiOrder> >(result.Data?.Data, result.Error));
}
/// <summary>
/// Fetch array of recent trades data
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="timeframe">time frame interval (optional): default "1d"</param>
/// <param name="since">return committed data since given time (milli-seconds) (optional): default 0</param>
/// <param name="limits">maximum number of items (optional): default 20</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <CompleteOrders> FetchCompleteOrdersAsync(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null)
{
var _result = new CompleteOrders(base_name, quote_name);
var _market = await this.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _timeframe = publicClient.ExchangeInfo.GetTimeframe(timeframe);
var _timestamp = publicClient.ExchangeInfo.GetTimestamp(timeframe);
var _params = new Dictionary <string, object>();
{
_params.Add("pair", _market.result.symbol);
if (since > 0)
{
_params.Add("since", since * 1000000);
}
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async("/0/public/Trades", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <JObject>(_json_value.Content);
{
var _json_orders = JArray.FromObject((_json_data["result"] as JObject)[_market.result.symbol]);
var _orders = new List <KCompleteOrderItem>();
foreach (var _o in _json_orders)
{
var _sideValue = _o[3].Value <string>();
var _orderValue = _o[4].Value <string>();
var _timeValue = (long)(_o[2].Value <decimal>() * 1000m);
var _price = _o[0].Value <decimal>();
var _quantity = _o[1].Value <decimal>();
_orders.Add(new KCompleteOrderItem
{
transactionId = (_timeValue * 1000).ToString(),
timestamp = _timeValue,
sideType = SideTypeConverter.FromString(_sideValue),
orderType = OrderTypeConverter.FromString(_orderValue),
price = _price,
quantity = _quantity,
amount = _quantity * _price
});
}
_result.result.AddRange(
_orders
.Where(t => t.timestamp >= since)
.OrderByDescending(t => t.timestamp)
.Take(limits)
);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
public OrderTypeConverterTests()
{
instance = new OrderTypeConverter();
}
