/// <summary> /// Cancels all of your orders. /// </summary> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async ValueTask <MyOrders> CancelAllOrdersAsync(Dictionary <string, object> args = null) { var _result = new MyOrders(); var _markets = await publicApi.LoadMarketsAsync(); if (_markets.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = tradeClient.MergeParamsAndArgs(args); var _json_value = await tradeClient.CallApiDelete1Async("/api/v1/order/all", _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 <List <BPlaceOrderItem> >(_json_value.Content); { _result.result.AddRange(_json_data); } } _result.SetResult(_json_result); } else { _result.SetResult(_markets); } return(_result); }
/// <summary> /// View Exchange Orders /// </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="limit">maximum number of items (optional): default 20</param> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async Task <MyOrders> FetchMyOrders(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limit = 20, Dictionary <string, object> args = null) { var _result = new MyOrders(base_name, quote_name); var _market = await publicApi.LoadMarket(_result.marketId); if (_market.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _timeframe = tradeClient.ExchangeInfo.GetTimeframe(timeframe); var _timestamp = tradeClient.ExchangeInfo.GetTimestamp(timeframe); var _params = new Dictionary <string, object>(); { _params.Add("currency_pair", _market.result.symbol); _params.Add("offset", 0); _params.Add("limit", limit); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiGet1Async("/user/orders", _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 <List <KMyOrderItem> >(_json_value.Content); { var _orders = _json_data .Where(o => o.symbol == _market.result.symbol && o.timestamp >= since) .OrderByDescending(o => o.timestamp) .Take(limit); foreach (var _o in _orders) { if (_o.price == 0) { _o.price = _o.avg_price; } _o.amount = _o.price * _o.quantity; _result.result.Add(_o); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Returns your open orders for a given market. /// </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="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async Task <MyOrders> FetchOpenOrders(string base_name, string quote_name, Dictionary <string, object> args = null) { var _result = new MyOrders(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("command", "returnOpenOrders"); _params.Add("currencyPair", _market.result.symbol); if (args != null) { foreach (var _a in args) { if (_params.ContainsKey(_a.Key) == true) { _params.Remove(_a.Key); } _params.Add(_a.Key, _a.Value); } } } var _json_value = await tradeClient.CallApiPost1Async("", _params); #if DEBUG _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _orders = tradeClient.DeserializeObject <List <PMyOrderItem> >(_json_value.Content); { foreach (var _o in _orders) { _o.orderStatus = OrderStatus.Open; _o.orderType = OrderType.Limit; _o.symbol = _market.result.symbol; _result.result.Add(_o); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Returns your open orders for all markets. /// </summary> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async ValueTask <MyOrders> FetchAllOpenOrders(Dictionary <string, object> args = null) { var _result = new MyOrders(); var _markets = await publicApi.LoadMarkets(); if (_markets.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = new Dictionary <string, object>(); { _params.Add("command", "returnOpenOrders"); _params.Add("currencyPair", "all"); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async("", _params); #if RAWJSON _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _orders = tradeClient.DeserializeObject <Dictionary <string, List <PMyOrderItem> > >(_json_value.Content); { foreach (var _o in _orders) { var _market = _markets.GetMarketBySymbol(_o.Key); if (_market == null) { continue; } foreach (var _order in _o.Value) { _order.symbol = _market.symbol; _order.orderStatus = OrderStatus.Open; _order.orderType = OrderType.Limit; _result.result.Add(_order); } } } } _result.SetResult(_json_result); } else { _result.SetResult(_markets); } return(_result); }
/// <summary> /// To get open orders on a symbol. /// </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="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async ValueTask <MyOrders> FetchOpenOrdersAsync(string base_name, string quote_name, Dictionary <string, object> args = null) { var _result = new MyOrders(base_name, quote_name); var _market = await publicApi.LoadMarketAsync(_result.marketId); if (_market.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = new Dictionary <string, object>(); { _params.Add("symbol", _market.result.symbol); _params.Add("reverse", true); _params.Add("filter", new CArgument { isJson = true, value = new Dictionary <string, object> { { "open", true } } }); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiGet1Async("/api/v1/order", _params); #if RAWJSON _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { //var _multiplier = publicApi.publicClient.ExchangeInfo.GetAmountMultiplier(_market.result.symbol, 1.0m); var _orders = tradeClient.DeserializeObject <List <BMyOrderItem> >(_json_value.Content); foreach (var _o in _orders) { _o.makerType = MakerType.Maker; _o.amount = _o.price * _o.quantity; _o.filled = Math.Max(_o.quantity - _o.remaining, 0); _o.cost = _o.price * _o.filled; _result.result.Add(_o); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Get your orders. /// </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 <MyOrders> FetchMyOrdersAsync(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null) { var _result = new MyOrders(base_name, quote_name); var _market = await publicApi.LoadMarketAsync(_result.marketId); if (_market.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _timeframe = tradeClient.ExchangeInfo.GetTimeframe(timeframe); var _timestamp = tradeClient.ExchangeInfo.GetTimestamp(timeframe); var _params = new Dictionary <string, object>(); { _params.Add("symbol", _market.result.symbol); _params.Add("count", limits); if (since > 0) { _params.Add("startTime", CUnixTime.ConvertToUtcTimeMilli(since).ToString("yyyy-MM-dd HH:mm")); } _params.Add("reverse", true); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiGet1Async("/api/v1/order", _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 <List <BMyOrderItem> >(_json_value.Content); { var _orders = _json_data .Where(o => o.symbol == _market.result.symbol && o.timestamp >= since) .OrderByDescending(o => o.timestamp) .Take(limits); foreach (var _o in _orders) { _o.amount = _o.price * _o.quantity; _result.result.Add(_o); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Cancel Open Orders /// </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_ids"></param> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async ValueTask <MyOrders> CancelOrdersAsync(string base_name, string quote_name, string[] order_ids, Dictionary <string, object> args = null) { var _result = new MyOrders(base_name, quote_name); var _market = await publicApi.LoadMarketAsync(_result.marketId); if (_market.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = new Dictionary <string, object>(); { _params.Add("symbol", _market.result.symbol); _params.Add("order_id", String.Join(",", order_ids)); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async("/v1/cancel_order.do", _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 <OCancelOrders>(_json_value.Content); foreach (var _o in _json_data.result) { var _order = new OPlaceOrderItem { symbol = _market.result.symbol, orderId = _o.orderId, orderType = OrderType.Limit, orderStatus = OrderStatus.Canceled, //sideType = sideType, //quantity = quantity, //price = price, //amount = quantity * price, //fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker, timestamp = CUnixTime.NowMilli, success = _o.success }; _result.result.Add(_order); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Cancel Open Orders /// </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_ids"></param> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async Task <MyOrders> CancelOrders(string base_name, string quote_name, string[] order_ids, Dictionary <string, object> args = null) { var _result = new MyOrders(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_pair", _market.result.symbol); _params.Add("id", new CArgument { isArray = true, value = order_ids }); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async("/user/orders/cancel", _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 <List <KCancelOrderItem> >(_json_value.Content); { foreach (var _o in _json_data) { var _order = new KMyOrderItem { orderId = _o.orderId, symbol = _market.result.symbol, timestamp = CUnixTime.NowMilli, orderStatus = _o.status == "success" ? OrderStatus.Canceled : OrderStatus.Unknown, orderType = OrderType.Limit }; _result.result.Add(_order); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Get all open orders on a symbol. Careful when accessing this with no symbol. /// </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="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async ValueTask <MyOrders> FetchOpenOrdersAsync(string base_name, string quote_name, Dictionary <string, object> args = null) { var _result = new MyOrders(base_name, quote_name); var _market = await publicApi.LoadMarketAsync(_result.marketId); if (_market.success == true) { okexClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = new Dictionary <string, object>(); { _params.Add("symbol", _market.result.symbol); _params.Add("order_id", -1); // if order_id is -1, then return all unfilled orders, otherwise return the order specified tradeClient.MergeParamsAndArgs(_params, args); } var _end_point = okexClient.CheckFuturesUrl(_market.result, "/order_info.do", "/future_order_info.do", _params); var _json_value = await okexClient.CallApiPost1Async(_end_point.endPoint, _end_point.args); #if RAWJSON _result.rawJson = _json_value.Content; #endif var _json_result = okexClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _json_data = okexClient.DeserializeObject <OMyOrders>(_json_value.Content); if (_json_data.success == true) { var _orders = _json_data.result .Where(o => o.symbol == _market.result.symbol) .OrderByDescending(o => o.timestamp); foreach (var _o in _orders) { _o.amount = _o.price * _o.quantity; _result.result.Add(_o); } } else { _json_result.SetResult(_json_data); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Get all orders that you currently have opened. A specific market can be requested. /// </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="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async Task <MyOrders> FetchOpenOrders(string base_name, string quote_name, Dictionary <string, object> args = null) { var _result = new MyOrders(base_name, quote_name); var _market = await publicApi.LoadMarket(_result.marketId); if (_market.success == true) { if (args.ContainsKey("account-id") && args["account-id"].ToString() != "") { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = new Dictionary <string, object>(); { _params.Add("account-id", args["account-id"].ToString()); _params.Add("symbol", _market.result.symbol); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiGet1Async("/v1/order/openOrders", _params); #if DEBUG _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _orders = tradeClient.DeserializeObject <HMyOrders>(_json_value.Content); { foreach (var _order in _orders.result) { _order.orderStatus = OrderStatus.Open; //_order.filled = _order.quantity - _order.remaining; _order.amount = _order.price * _order.quantity; _result.result.Add(_order); } } } _result.SetResult(_json_result); } else { _result.SetFailure("required args[account-id]"); } } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// List Open Orders /// </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="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async Task <MyOrders> FetchOpenOrders(string base_name, string quote_name, Dictionary <string, object> args = null) { var _result = new MyOrders(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_pair", _market.result.symbol); _params.Add("offset", 0); _params.Add("limit", 50); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiGet1Async("/user/orders/open", _params); #if DEBUG _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _orders = tradeClient.DeserializeObject <List <KMyOpenOrderItem> >(_json_value.Content); { foreach (var _o in _orders) { _o.symbol = _market.result.symbol; _o.quantity = _o.totalValue.value; _o.price = _o.priceValue.value; _o.amount = _o.quantity * _o.price; _o.filled = _o.quantity - _o.openValue.value; _o.cost = _o.filled * _o.price; _o.orderStatus = OrderStatus.Open; _result.result.Add(_o); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// With best effort, cancel open orders. The response is a list of ids of the canceled orders. /// </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_ids"></param> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async Task <MyOrders> CancelOrders(string base_name, string quote_name, string[] order_ids, Dictionary <string, object> args = null) { var _result = new MyOrders(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("product_id", _market.result.symbol); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiDelete1Async($"/orders", _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 <JArray>(_json_value.Content); { foreach (var _o in _json_data) { var _order = new GMyOrderItem { orderId = _o.Value <string>(), symbol = _market.result.symbol, timestamp = CUnixTime.NowMilli, orderStatus = OrderStatus.Canceled, orderType = OrderType.Limit }; _result.result.Add(_order); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// View your latest inactive orders. /// Limited to last 3 days and 1 request per minute. /// </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 <MyOrders> FetchMyOrders(string base_name, string quote_name, string timeframe = "1d", long since = 0, int limits = 20, Dictionary <string, object> args = null) { var _result = new MyOrders(base_name, quote_name); var _market = await publicApi.LoadMarket(_result.marketId); if (_market.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _timeframe = tradeClient.ExchangeInfo.GetTimeframe(timeframe); var _timestamp = tradeClient.ExchangeInfo.GetTimestamp(timeframe); var _params = new Dictionary <string, object>(); { _params.Add("symbol", _market.result.symbol); _params.Add("states", "pre-submitted,submitted,partial-filled,partial-canceled,filled,canceled"); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiGet1Async("/v1/order/orders", _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 <HMyOrders>(_json_value.Content); { var _orders = _json_data.result .Where(o => o.symbol == _market.result.symbol && o.timestamp >= since) .OrderByDescending(o => o.timestamp) .Take(limits); foreach (var _o in _orders) { _o.amount = _o.price * _o.quantity; _result.result.Add(_o); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Get all open orders /// </summary> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async ValueTask <MyOrders> FetchAllOpenOrdersAsync(Dictionary <string, object> args = null) { var _result = new MyOrders(); var _markets = await publicApi.LoadMarketsAsync(); if (_markets.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = tradeClient.MergeParamsAndArgs(args); var _json_value = await tradeClient.CallApiPost1Async("/0/private/OpenOrders", _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 <KResponse <KMyOpenOrders> >(_json_value.Content); { var _orders = _json_data.result.open .OrderByDescending(o => o.Value.timestamp); foreach (var _o in _orders) { _o.Value.orderId = _o.Key; var _market = _markets.result.Values.Where(m => (m as KMarketItem).altname == _o.Value.symbol).SingleOrDefault(); if (_market != null) { _o.Value.symbol = _market.symbol; } _o.Value.price = _o.Value.descr.price != 0.0m ? _o.Value.descr.price : _o.Value.price; _o.Value.amount = _o.Value.price * _o.Value.quantity; _result.result.Add(_o.Value); } } } _result.SetResult(_json_result); } else { _result.SetResult(_markets); } return(_result); }
/// <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="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async ValueTask <MyOrders> FetchOpenOrdersAsync(string base_name, string quote_name, Dictionary <string, object> args = null) { var _result = new MyOrders(base_name, quote_name); var _market = await publicApi.LoadMarketAsync(_result.marketId); if (_market.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = new Dictionary <string, object>(); { _params.Add("symbol", _market.result.symbol); _params.Add("status", 0); _params.Add("current_page", 1); _params.Add("page_length", 100); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async("/v1/order_history.do", _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 <OMyOrders>(_json_value.Content); if (_json_data.success == true) { foreach (var _o in _json_data.result) { _o.amount = _o.price * _o.quantity; _result.result.Add(_o); } } else { _json_result.SetFailure(_json_data.message); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Order_V2 - My Limit Orders /// </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="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async ValueTask <MyOrders> FetchOpenOrders(string base_name, string quote_name, Dictionary <string, object> args = null) { var _result = new MyOrders(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); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async("/v2/order/limit_orders", _params); #if RAWJSON _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _orders = tradeClient.DeserializeObject <CMyOpenOrders>(_json_value.Content); if (_orders.success == true) { foreach (var _order in _orders.limitOrders) { _order.symbol = _market.result.symbol; _order.amount = _order.quantity * _order.price; _result.result.Add(_order); } } else { _json_result.SetResult(_orders); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Get all open orders on a symbol. Careful when accessing this with no symbol. /// </summary> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async Task <MyOrders> FetchAllOpenOrders(Dictionary <string, object> args = null) { var _result = new MyOrders(); var _markets = await publicApi.LoadMarkets(); if (_markets.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = tradeClient.MergeParamsAndArgs(args); var _json_value = await tradeClient.CallApiPost1Async("/v2/open_orders/all/", _params); #if DEBUG _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _orders = tradeClient.DeserializeObject <List <BOpenOrderItem> >(_json_value.Content); { foreach (var _o in _orders) { var _market = _markets.GetMarketByMarketId(_o.marketId); _o.symbol = _market.symbol; _o.orderStatus = OrderStatus.Open; _o.makerType = MakerType.Maker; _o.orderType = OrderType.Limit; _o.amount = _o.price * _o.quantity; _o.remaining = _o.quantity; _o.count++; _result.result.Add(_o); } } } _result.SetResult(_json_result); } else { _result.SetResult(_markets); } return(_result); }
/// <summary> /// Cancel orders. Send multiple order IDs to cancel in bulk. /// </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_ids"></param> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async Task <MyOrders> CancelOrders(string base_name, string quote_name, string[] order_ids, Dictionary <string, object> args = null) { var _result = new MyOrders(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("orderID", order_ids); if (args != null) { foreach (var _a in args) { if (_params.ContainsKey(_a.Key) == true) { _params.Remove(_a.Key); } _params.Add(_a.Key, _a.Value); } } } var _json_value = await tradeClient.CallApiDelete1Async("/api/v1/order", _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 <List <BPlaceOrderItem> >(_json_value.Content); { _result.result.AddRange(_json_data); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Returns limit orders in pending state submission to the orderbook, or already active (they may be partially filled). /// </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="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async Task <MyOrders> FetchOpenOrders(string base_name, string quote_name, Dictionary <string, object> args = null) { var _result = new MyOrders(base_name, quote_name); var _market = await publicApi.LoadMarket(_result.marketId); if (_market.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = tradeClient.MergeParamsAndArgs(args); var _json_value = await tradeClient.CallApiPost1Async($"/{_market.result.symbol}/money/orders", _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 <AMyOrders>(_json_value.Content); if (_json_data.success == true) { foreach (var _o in _json_data.result) { _o.symbol += _o.currency; _o.quantity = _o.amountValue.value; _o.price = _o.priceValue.value; _o.filled = _o.effectiveValue.value; _o.amount = _o.price * _o.quantity; _result.result.Add(_o); } } else { _json_result.SetFailure(_json_data.message); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Cancel all active orders at once. /// </summary> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async Task <MyOrders> CancelAllOrders(Dictionary <string, object> args = null) { var _result = new MyOrders(); var _markets = await publicApi.LoadMarkets(); if (_markets.success == true) { if (args.ContainsKey("account-id") && args["account-id"].ToString() != "") { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = tradeClient.MergeParamsAndArgs(args); var _json_value = await tradeClient.CallApiPost1Async($"/v1/order/orders/batchCancelOpenOrders", _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 <HCancelAllOrders>(_json_value.Content); { if (_json_data.success == true) { _result.result.Add(_json_data.result); } else { _result.SetFailure(); } } } _result.SetResult(_json_result); } else { _result.SetFailure("required args[account-id]"); } } else { _result.SetResult(_markets); } return(_result); }
/// <summary> /// With best effort, cancel all open orders. The response is a list of ids of the canceled orders. /// </summary> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async Task <MyOrders> CancelAllOrders(Dictionary <string, object> args = null) { var _result = new MyOrders(); var _markets = await publicApi.LoadMarkets(); if (_markets.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = tradeClient.MergeParamsAndArgs(args); // symbol이 required 인지 아닌지 document에 안나와있음. required면 cancelAllOrders 제공안함. var _json_value = await tradeClient.CallApiDelete1Async($"/orders", _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 <JArray>(_json_value.Content); { foreach (var _o in _json_data) { var _order = new GMyOrderItem { orderId = _o.Value <string>(), timestamp = CUnixTime.NowMilli, orderStatus = OrderStatus.Canceled, orderType = OrderType.Limit }; _result.result.Add(_order); } } } _result.SetResult(_json_result); } else { _result.SetResult(_markets); } return(_result); }
/// <summary> /// Cancel Open Orders /// </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_ids"></param> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async ValueTask <MyOrders> CancelOrders(string base_name, string quote_name, string[] order_ids, Dictionary <string, object> args = null) { var _result = new MyOrders(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("order_ids", Array.ConvertAll(order_ids, s => int.Parse(s))); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async("/v1/order/cancel/multi", _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 <BCancelAllOrders>(_json_value.Content); { if (_json_data.result.IndexOf("Orders cancelled") < 0) { _result.SetFailure(_json_data.result); } else { _result.SetSuccess(); } } _json_result.SetResult(_result); } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Get open orders /// </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="args">userref = restrict results to given user reference id (optional)</param> /// <returns></returns> public override async Task <MyOrders> FetchOpenOrders(string base_name, string quote_name, Dictionary <string, object> args = null) { var _result = new MyOrders(base_name, quote_name); var _market = await publicApi.LoadMarket(_result.marketId); if (_market.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _kmarket = _market.result as KMarketItem; var _params = tradeClient.MergeParamsAndArgs(args); var _json_value = await tradeClient.CallApiPost1Async("/0/private/OpenOrders", _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 <KResponse <KMyOpenOrders> >(_json_value.Content); { var _orders = _json_data.result.open .Where(o => o.Value.symbol == _kmarket.altname) .OrderByDescending(o => o.Value.timestamp); foreach (var _o in _orders) { _o.Value.orderId = _o.Key; _o.Value.price = _o.Value.descr.price != 0.0m ? _o.Value.descr.price : _o.Value.price; _o.Value.amount = _o.Value.price * _o.Value.quantity; _result.result.Add(_o.Value); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Get Open Orders /// </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="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async ValueTask <MyOrders> FetchOpenOrders(string base_name, string quote_name, Dictionary <string, object> args = null) { var _result = new MyOrders(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("product_id", _market.result.symbol); _params.Add("status", "live"); // filter orders based on status, ccxt 참고 tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiGet1Async("/orders", _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 <QMyOrders>(_json_value.Content); { var _orders = _json_data.result .Where(o => o.symbol == _market.result.symbol) .OrderByDescending(o => o.timestamp); foreach (var _o in _orders) { _o.amount = _o.price * _o.quantity; _result.result.Add(_o); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Get Open Orders /// </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="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async ValueTask <MyOrders> FetchOpenOrdersAsync(string base_name, string quote_name, Dictionary <string, object> args = null) { var _result = new MyOrders(base_name, quote_name); var _market = await publicApi.LoadMarketAsync(_result.marketId); if (_market.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = new Dictionary <string, object>(); { _params.Add("status", "open"); _params.Add("instrument", _market.result.symbol); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiGet1Async($"/v1/wallets/{__wallet_id}/orders", _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 <List <TMyOrderItem> >(_json_value.Content); { var _orders = _json_data .Where(o => OrderStatusConverter.IsAlive(o.orderStatus) == true) .OrderByDescending(o => o.timestamp); foreach (var _o in _orders) { _o.amount = _o.price * _o.quantity; _result.result.Add(_o); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Cancel all orders for given pair /// </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_ids"></param> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async Task <MyOrders> CancelOrders(string base_name, string quote_name, string[] order_ids, Dictionary <string, object> args = null) { var _result = new MyOrders(base_name, quote_name); var _market = await publicApi.LoadMarket(_result.marketId); if (_market.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = tradeClient.MergeParamsAndArgs(args); var _json_value = await tradeClient.CallApiPost1Async($"/cancel_orders/{_market.result.symbol}", _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 <CCancelOrders>(_json_value.Content); { foreach (var _o in _json_data.result) { var _order = new CMyOrderItem { orderId = _o.orderId, symbol = _market.result.symbol, timestamp = CUnixTime.NowMilli, orderStatus = _json_data.message == "ok" ? OrderStatus.Canceled : OrderStatus.Unknown, orderType = OrderType.Limit }; _result.result.Add(_order); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Get all orders that you currently have opened. A specific market can be requested. /// </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="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async ValueTask <MyOrders> FetchOpenOrders(string base_name, string quote_name, Dictionary <string, object> args = null) { var _result = new MyOrders(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("method", "getUnfinishedOrdersIgnoreTradeType"); _params.Add("currency", _market.result.symbol); //_params.Add("pageIndex", 1); //_params.Add("pageSize", 100); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiGet1Async("/getUnfinishedOrdersIgnoreTradeType", _params); #if RAWJSON _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _orders = tradeClient.DeserializeObject <List <ZMyOrderItem> >(_json_value.Content); { foreach (var _order in _orders) { _order.amount = _order.price * _order.quantity; _result.result.Add(_order); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Create a new limit bulk order. /// </summary> /// <param name="orders"></param> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public async Task <MyOrders> CreateBulkOrder(List <BBulkOrderItem> orders, Dictionary <string, object> args = null) { var _result = new MyOrders(); tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); { var _params = tradeClient.MergeParamsAndArgs( new Dictionary <string, object> { { "orders", orders } }, args ); var _json_value = await tradeClient.CallApiPost1Async("/api/v1/order/bulk", _params); #if RAWJSON _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _orders = tradeClient.DeserializeObject <List <BMyOrderItem> >(_json_value.Content); { _result.result = _orders.ToList <IMyOrderItem>(); } } _result.SetResult(_json_result); } return(_result); }
/// <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="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async Task <MyOrders> FetchOpenOrders(string base_name, string quote_name, Dictionary <string, object> args = null) { var _result = new MyOrders(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("market", _market.result.symbol); _params.Add("state", "wait"); _params.Add("page", 1); _params.Add("order_by", "asc"); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiGet1Async("/orders", _params); #if DEBUG _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _orders = tradeClient.DeserializeObject <List <UMyOrderItem> >(_json_value.Content); { foreach (var _o in _orders) { _o.amount = _o.price * _o.quantity; _result.result.Add(_o); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Get all orders that you currently have opened. A specific market can be requested. /// </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="args">Add additional attributes for each exchange</param> /// <returns></returns> public override async Task <MyOrders> FetchOpenOrders(string base_name, string quote_name, Dictionary <string, object> args = null) { var _result = new MyOrders(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("symbol", _market.result.symbol); _params.Add("state", 0); // orderState: 0 uncomplete, 1 completed tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async("/api/v1/trade/orderInfos", _params); #if DEBUG _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _orders = tradeClient.DeserializeObject <BMyOrders>(_json_value.Content); { foreach (var _order in _orders.result) { _order.orderStatus = OrderStatus.Open; _order.amount = _order.price * _order.quantity; _result.result.Add(_order); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }