/// <summary>
/// 지정가 주문
/// </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="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> CreateLimitOrder(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("currencyPair", _market.result.symbol);
_params.Add("rate", price);
_params.Add("amount ", quantity);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/1/private/{_buy_sell}", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <GPlaceOrderItem>(_json_value.Content);
{
_json_data.amount = _json_data.quantity * _json_data.price;
_json_data.orderType = OrderType.Limit;
_json_data.orderStatus = _json_data.remaining_volume == 0.0m ? OrderStatus.Closed
: _json_data.filled == 0.0m ? OrderStatus.Open
: OrderStatus.Partially;
_json_data.quantity = _json_data.remaining_volume + _json_data.filled;
_json_data.sideType = SideTypeConverter.FromString(_buy_sell);
_json_data.symbol = _market.result.symbol;
_json_data.timestamp = CUnixTime.NowMilli;
_result.result = _json_data;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <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 Task <CompleteOrders> FetchCompleteOrders(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.LoadMarket(_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>();
{
var _limit = limits <= 1 ? 1
: limits <= 1000 ? limits
: 1000;
_params.Add("sort", "-1"); // if = -1 it sorts results returned with old < new
_params.Add("limit", _limit);
if (since > 0)
{
_params.Add("start", since); // timestamp false [time] Only show trades at or after this timestamp
}
publicClient.MergeParamsAndArgs(_params, args);
}
var _section = "hist"; // Section(string) REQUIRED Available values: "last", "hist"
var _json_value = await publicClient.CallApiGet1Async($"/v2/trades/t{_market.result.symbol.ToUpper()}/{_section}", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <List <JArray> >(_json_value.Content);
{
var _orders = new List <BCompleteOrderItem>();
foreach (var _o in _json_data)
{
var _transactionId = _o[0].Value <string>();
var _timevalue = _o[1].Value <long>();
var _quantity = _o[2].Value <decimal>();
var _price = _o[3].Value <decimal>();
var _sideValue = (_quantity < 0) ? "sell" : "buy";
if (_quantity < 0)
{
_quantity = -_quantity;
}
_orders.Add(new BCompleteOrderItem()
{
transactionId = _transactionId,
timestamp = _timevalue,
fillType = FillType.Fill,
sideType = SideTypeConverter.FromString(_sideValue),
orderType = OrderType.Limit,
quantity = _quantity,
price = _price,
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);
}
/// <summary>
/// Check an order's status.
/// </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="order_id">Order number registered for sale or purchase</param>
/// <param name="args">Add additional attributes for each exchange: (require) type</param>
/// <returns></returns>
public override async ValueTask <MyOrder> FetchMyOrder(string base_name, string quote_name, string order_id, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("currency", _market.result.symbol);
_params.Add("order_id", order_id);
_params.Add("type", "");
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("/info/order_detail", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <BMyOrders>(_json_value.Content);
if (_json_data.success == true)
{
var _type = (_params.ContainsKey("type") == true) ? _params["type"].ToString() : "";
var _order = new BMyOrderItem
{
orderId = order_id,
symbol = _market.result.symbol,
payment_currency = quote_name,
sideType = SideTypeConverter.FromString(_type),
makerType = MakerType.Unknown,
orderStatus = OrderStatus.Closed,
orderType = OrderType.Limit,
timestamp = CUnixTime.NowMilli
};
foreach (var _o in _json_data.result)
{
//if (String.IsNullOrEmpty(_order.contract_id) == true)
// _order.contract_id = _o.contract_id;
if (_order.sideType != _o.sideType)
{
continue;
}
if (_order.timestamp > _o.timestamp)
{
_order.timestamp = _o.timestamp;
}
_order.quantity += _o.quantity;
_order.fee += _o.fee;
_order.amount += _o.amount;
_order.count++;
}
_order.price = _order.amount / _order.quantity;
_result.result = _order;
}
else
{
_json_result.SetResult(_json_data);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <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);
}
