/// <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 ? "bid" : "ask"; var _params = new Dictionary <string, object>(); { _params.Add("market", _market.result.symbol); _params.Add("side", _buy_sell); _params.Add("volume", quantity); _params.Add("price", price); _params.Add("ord_type", "limit"); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async($"/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 <UPlaceOrderItem>(_json_value.Content); { _json_data.amount = _json_data.quantity * _json_data.price; _result.result = _json_data; } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Close a position /// </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="orderType">The type of order is limit, market or position</param> /// <param name="price">price of coin</param> /// <param name="args">Add additional attributes for each exchange</param> /// <returns></returns> public async Task <MyOrder> ClosePosition(string base_name, string quote_name, OrderType orderType, decimal price = 0.0m, Dictionary <string, object> args = null) { var _result = new MyOrder(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("execInst", "Close"); if (orderType == OrderType.Limit) { _params.Add("price", price); } tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async("/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 _order = tradeClient.DeserializeObject <BMyOrderItem>(_json_value.Content); { _result.result = _order; } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Get order details /// </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</param> /// <returns></returns> public override async Task <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("id", order_id); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async("/get_order/", _params); #if DEBUG _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _order = tradeClient.DeserializeObject <CMyOrderItem>(_json_value.Content); if (_order != null) { _order.amount = _order.price * _order.quantity; _result.result = _order; } else { _json_result.SetFailure("Order not found", ErrorCode.OrderNotFound); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Used to retrieve a single order by uuid. /// </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</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("id", order_id); _params.Add("method", "getOrder"); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiGet1Async("/getOrder", _params); #if RAWJSON _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _order = tradeClient.DeserializeObject <ZMyOrderItem>(_json_value.Content); { _order.amount = _order.quantity * _order.price; _order.orderType = OrderType.Limit; _result.result = _order; } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Used to cancel a buy or sell order. /// </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="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 ValueTask <MyOrder> CancelOrderAsync(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null) { var _result = new MyOrder(base_name, quote_name); var _market = await publicApi.LoadMarketAsync(_result.marketId); if (_market.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = tradeClient.MergeParamsAndArgs(args); var _json_value = await tradeClient.CallApiDelete1Async($"/api/exchange/orders/{order_id}", _params); #if RAWJSON _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _order = tradeClient.DeserializeObject <CCancelOrderItem>(_json_value.Content); { _order.symbol = _market.result.symbol; _order.orderType = OrderType.Limit; _order.orderStatus = OrderStatus.Canceled; _order.sideType = sideType; _order.quantity = quantity; _order.price = price; _order.amount = (_order.quantity * _order.price).Normalize(); //_order.fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker; _order.timestamp = CUnixTime.NowMilli; } _result.result = _order; } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Used to retrieve a single order by uuid. /// </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</param> /// <returns></returns> public override async Task <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("symbol", _market.result.symbol); _params.Add("orderId", order_id); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async("/api/v1/trade/orderInfo", _params); #if DEBUG _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _order = tradeClient.DeserializeObject <BMyOrder>(_json_value.Content); { var _o = _order.result; _o.amount = _o.quantity * _o.price; _o.orderType = OrderType.Limit; _result.result = _o; } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Get Order /// </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</param> /// <returns></returns> public override async Task <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("product_code", _market.result.symbol); _params.Add("child_order_id", order_id); tradeClient.MergeParamsAndArgs(_params, args); } // 실제 넘어오는 데이터 확인해야함. sample에는 list로 넘어옴. var _json_value = await tradeClient.CallApiGet1Async("/v1/me/getchildorders", _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 <BMyOrderItem> >(_json_value.Content); var _order = _orders.Where(o => o.orderId == order_id).SingleOrDefault(); _order.amount = _order.price * _order.quantity; _result.result = _order; } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Cancel an active order. /// </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="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> CancelOrder(string base_name, string quote_name, string order_id, 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 _params = tradeClient.MergeParamsAndArgs( new Dictionary <string, object> { { "id", order_id } }, args ); var _json_value = await tradeClient.CallApiPost1Async($"/v2/cancel_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 <BPlaceOrderItem>(_json_value.Content); { _json_data.orderStatus = OrderStatus.Canceled; _json_data.amount = (_json_data.quantity * _json_data.price).Normalize(); _result.result = _json_data; } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Get the status of an order. Is it active? Was it cancelled? To what extent has it been executed? etc. /// </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</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("order_id", Convert.ToInt64(order_id)); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async("/v1/order/status", _params); #if RAWJSON _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _orderItem = tradeClient.DeserializeObject <BMyOrderItem>(_json_value.Content); { _orderItem.amount = _orderItem.price * _orderItem.quantity; _result.result = _orderItem; } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Cancel an Order /// </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="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 ValueTask <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, 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 _params = tradeClient.MergeParamsAndArgs(args); var _json_value = await tradeClient.CallApiPut1Async($"/orders/{order_id}/cancel", _params); #if DEBUG _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { if (_json_result.success == true) { var _order = tradeClient.DeserializeObject <QPlaceOrderItem>(_json_value.Content); { _order.amount = (_order.quantity * _order.price).Normalize(); _order.fee = _order.amount * tradeClient.ExchangeInfo.Fees.trading.maker; _result.result = _order; } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Update an order. /// </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="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 async Task <MyOrder> UpdateOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null) { var _result = new MyOrder(base_name, quote_name); var _market = await publicApi.LoadMarketAsync(_result.marketId); if (_market.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = tradeClient.MergeParamsAndArgs( new Dictionary <string, object> { { "orderID", order_id }, { "orderQty", quantity }, { "price", price } }, args ); var _json_value = await tradeClient.CallApiPut1Async("/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 <BPlaceOrderItem>(_json_value.Content); _result.result = _json_data; } _result.SetResult(_json_result); } else { _result.SetResult(_market); } 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="order_id">Order number registered for sale or purchase</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 ValueTask <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, 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 _params = new Dictionary <string, object>(); { _params.Add("uuid", order_id); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiDelete1Async($"/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 <UPlaceOrderItem>(_json_value.Content); { _json_data.amount = _json_data.quantity * _json_data.price; _result.result = _json_data; } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Get Order /// </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</param> /// <returns></returns> public override async ValueTask <MyOrder> FetchMyOrderAsync(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.LoadMarketAsync(_result.marketId); if (_market.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _params = tradeClient.MergeParamsAndArgs(args); var _json_value = await tradeClient.CallApiGet1Async($"/v1/wallets/{__wallet_id}/orders/{order_id}", _params); #if RAWJSON _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _order = tradeClient.DeserializeObject <TMyOrderItem>(_json_value.Content); { _order.amount = _order.price * _order.quantity; _result.result = _order; } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Place an market order. /// </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">fiat rate 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> CreateMarketOrder(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("currency_pair", _market.result.symbol); _params.Add("type", "market"); if (sideType == SideType.Bid) { _params.Add("fiat_amount", price * quantity); } else { _params.Add("coin_amount", quantity); } 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($"/user/orders/{_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 <KPlaceOrder>(_json_value.Content); if (_json_data.success == true) { var _order = new KPlaceOrderItem { orderId = _json_data.orderId, symbol = _market.result.symbol, sideType = sideType, orderType = OrderType.Market, orderStatus = OrderStatus.Open, timestamp = CUnixTime.NowMilli, price = price, quantity = quantity, amount = quantity * price, //fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker, filled = 0m, cost = 0m }; _result.result = _order; } else { _json_result.SetResult(_json_data); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Order_V2 - Limit Buy/Sell /// </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 ValueTask <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("currency", _market.result.symbol); _params.Add("price", price); _params.Add("qty", quantity); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async($"/v2/order/limit_{_buy_sell}", _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 <CPlaceOrder>(_json_value.Content); if (_json_data.success == true) { var _order = new CPlaceOrderItem { orderId = _json_data.orderId.ToUpper(), timestamp = CUnixTime.NowMilli, orderType = OrderType.Limit, orderStatus = OrderStatus.Open, sideType = sideType, price = price, quantity = quantity, amount = quantity * price, //fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker, filled = 0m, cost = 0m }; _result.result = _order; } else { _json_result.SetResult(_json_data); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } 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="order_id">Order number registered for sale or purchase</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 ValueTask <MyOrder> CancelOrderAsync(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null) { var _result = new MyOrder(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", order_id); 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); var _cancel = _json_data.result.FirstOrDefault(); if (_cancel != null && _cancel.success == true) { var _order = new OPlaceOrderItem { symbol = _market.result.symbol, orderId = order_id, 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 = true }; _result.result = _order; } else { _json_result.SetFailure(errorCode: ErrorCode.OrderNotFound); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Order_V2 - Cancel Order /// </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="quantity">amount of coin</param> /// <param name="price">fiat rate 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> CancelOrder(string base_name, string quote_name, string order_id, 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 _params = new Dictionary <string, object>(); { _params.Add("currency", _market.result.symbol); _params.Add("order_id", order_id); _params.Add("price", price); _params.Add("qty", quantity); _params.Add("is_ask", sideType == SideType.Ask ? 1 : 0); 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("/v2/order/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<JToken>(_json_value.Content); { var _order = new MyOrderItem { orderId = order_id.ToUpper(), symbol = _market.result.symbol, sideType = sideType, quantity = quantity, price = price, amount = quantity * price }; _result.result = _order; } } _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> /// Send in a new order. /// </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 ValueTask <MyOrder> CreateMarketOrderAsync(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.LoadMarketAsync(_result.marketId); if (_market.success == true) { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _buy_sell = sideType == SideType.Bid ? "buy_market" : "sell_market"; var _params = new Dictionary <string, object>(); { _params.Add("symbol", _market.result.symbol); // token_krw (ex. btc_krw) _params.Add("type", _buy_sell); // buy,sell if (sideType == SideType.Bid) { _params.Add("price", price); // 1호 매수가격보다 커야 함. } else { _params.Add("amount", quantity); // 1호 매도가격보다 커야 함. } tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async("/v1/trade.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 <OPlaceOrder>(_json_value.Content); { var _order = new OPlaceOrderItem { orderId = _json_data.result.orderId, symbol = _market.result.symbol, orderType = OrderType.Market, orderStatus = OrderStatus.Open, sideType = sideType, quantity = quantity, price = price, amount = quantity * price, //fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker, timestamp = CUnixTime.NowMilli }; _result.result = _order; } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } 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="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 ValueTask <MyOrder> CreateMarketOrder(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("currency", _market.result.baseId); _params.Add("units", quantity); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async($"/trade/market_{_buy_sell}", _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 <BPlaceOrders>(_json_value.Content); if (_json_data.success == true) { var _market_order = new BPlaceOrderItem { orderId = _json_data.orderId, sideType = sideType, orderType = OrderType.Market, orderStatus = OrderStatus.Open, timestamp = Convert.ToInt64(_json_data.orderId), price = price, quantity = quantity, amount = quantity * price, //fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker, filled = 0m, cost = 0m }; foreach (var _trade in _json_data.data) { _market_order.filled += _trade.quantity; _market_order.cost += _trade.amount + _trade.fee; } _result.result = _market_order; } else { _json_result.SetResult(_json_data); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// bithumb 회원 판/구매 거래 취소 /// </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="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 ValueTask <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, 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 ? "bid" : "ask"; var _params = new Dictionary <string, object>(); { _params.Add("currency", _market.result.symbol); _params.Add("order_id", order_id); _params.Add("type", _buy_sell); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async("/trade/cancel", _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 <BPlaceOrder>(_json_value.Content); if (_json_data.success == true) { var _cancel_order = new BPlaceOrderItem { orderId = order_id, symbol = _market.result.symbol, orderStatus = OrderStatus.Canceled, sideType = sideType, quantity = quantity, price = price, amount = quantity * price }; _result.result = _cancel_order; } else { _json_result.SetResult(_json_data); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// create new market order /// </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 ValueTask <MyOrder> CreateMarketOrderAsync(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.LoadMarketAsync(_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("pair", _market.result.symbol); _params.Add("type", _buy_sell); _params.Add("ordertype", "market"); //_params.Add("price", price); // (optional. dependent upon ordertype) //_params.Add("price2", "?"); // secondary price (optional. dependent upon ordertype) _params.Add("volume", quantity); // order volume in lots tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async($"/0/private/AddOrder", _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 <KMyPlaceOrder> >(_json_value.Content); { foreach (var _p in _json_data.result.transactionIds) { var _order = new KMyPlaceOrderItem { orderId = _p, symbol = _market.result.symbol, timestamp = CUnixTime.NowMilli, orderType = OrderType.Market, sideType = sideType, quantity = quantity, price = price, amount = quantity * price }; _result.result = _order; break; } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Place a market order /// </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> CreateMarketOrder(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 ? "bid" : "ask"; var _params = new Dictionary <string, object>(); { // To place a market order, do not specify the value of price_int _params.Add("type", _buy_sell); _params.Add("amount_int", quantity * 100000000.0m); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async($"/{_market.result.symbol}/money/order/add", _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 <APlaceOrder>(_json_value.Content); if (_json_data.success == true) { var _order = new AMyOrderItem { symbol = _market.result.symbol, orderId = _json_data.result.orderId, orderType = OrderType.Market, orderStatus = OrderStatus.Open, sideType = sideType, quantity = quantity, price = price, amount = quantity * price, //fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker, timestamp = CUnixTime.NowMilli }; _result.result = _order; } else { _json_result.SetFailure(_json_data.message); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Cancel Order /// </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="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 ValueTask <MyOrder> CancelOrderAsync(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null) { var _result = new MyOrder(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", Convert.ToInt64(order_id)); tradeClient.MergeParamsAndArgs(_params, args); } var _end_point = okexClient.CheckFuturesUrl(_market.result, "/cancel_order.do", "/future_cancel.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 <OCancelOrderItem>(_json_value.Content); { var _order_id = ""; var _order_status = OrderStatus.Unknown; { if (String.IsNullOrEmpty(_json_data.success) == false) { _order_id = _json_data.success; _order_status = OrderStatus.Canceled; } else if (String.IsNullOrEmpty(_json_data.failure) == false) { _order_id = _json_data.failure; _order_status = OrderStatus.Unknown; } } if (String.IsNullOrEmpty(_order_id) == false) { var _order = new OMyOrderItem { symbol = _market.result.symbol, orderId = _order_id, orderType = OrderType.Limit, orderStatus = _order_status, sideType = sideType, quantity = quantity, price = price, amount = quantity * price, //fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker, timestamp = CUnixTime.NowMilli }; _result.result = _order; } else { _json_result.SetFailure(); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Place Market Order. /// </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 ValueTask <MyOrder> CreateMarketOrderAsync(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.LoadMarketAsync(_result.marketId); if (_market.success == true) { okexClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _buy_sell = sideType == SideType.Bid ? "buy_market" : "sell_market"; var _params = new Dictionary <string, object>(); { _params.Add("symbol", _market.result.symbol); _params.Add("type", _buy_sell); _params.Add("amount", quantity); tradeClient.MergeParamsAndArgs(_params, args); } var _end_point = okexClient.CheckFuturesUrl(_market.result, "/trade.do", "/future_trade.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 <OPlaceOrderItem>(_json_value.Content); if (_json_data.result == true) { var _order = new OPlaceOrderItem { orderId = _json_data.orderId.ToUpper(), timestamp = CUnixTime.NowMilli, orderType = OrderType.Market, orderStatus = OrderStatus.Open, sideType = sideType, price = price, quantity = quantity, amount = quantity * price, //fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker }; _result.result = _order; } else { _result.SetFailure(); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Used to cancel a buy or sell order. /// </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="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 ValueTask <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, 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 _params = new Dictionary <string, object>(); { _params.Add("method", "cancelOrder"); _params.Add("currency", _market.result.symbol); _params.Add("id", order_id); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiGet1Async($"/cancelOrder", _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 <ZPlaceOrder>(_json_value.Content); if (_json_data.success == true) { var _order = new ZPlaceOrderItem { orderId = order_id, symbol = _market.result.symbol, 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 }; _result.result = _order; } else { _json_result.SetResult(_json_data); } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Places a limit order in 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="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 ValueTask <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 _params = new Dictionary <string, object>(); { _params.Add("command", sideType == SideType.Bid ? "buy" : "sell"); _params.Add("currencyPair", _market.result.symbol); _params.Add("rate", price.ToStringNormalized()); _params.Add("amount", quantity.ToStringNormalized()); 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 _json_data = tradeClient.DeserializeObject <PPlaceOrders>(_json_value.Content); { var _order = new PPlaceOrderItem { orderId = _json_data.orderId, sideType = sideType, orderType = OrderType.Limit, orderStatus = OrderStatus.Open, timestamp = _json_data.resultingTrades.Max(t => t.timestamp), price = price, quantity = quantity, amount = quantity * price, filled = 0m, cost = 0m }; foreach (var _trade in _json_data.resultingTrades) { _order.filled += _trade.quantity; _order.cost += _trade.price * _trade.quantity; } _result.result = _order; } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Cancel Open Order /// </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="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> CancelOrder(string base_name, string quote_name, string order_id, 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 _params = new Dictionary <string, object>(); { _params.Add("currency_pair", _market.result.symbol); _params.Add("id", order_id); 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); { var _cancel_order = _json_data.FirstOrDefault(); if (_cancel_order != null) { var _order = new KMyOrderItem { orderId = _cancel_order.orderId, symbol = _market.result.symbol, timestamp = CUnixTime.NowMilli, orderStatus = OrderStatus.Canceled, orderType = OrderType.Limit, sideType = sideType, quantity = quantity, price = price, amount = quantity * price }; _result.result = _order; var _success = _cancel_order.status == "success"; if (_success == false) { _json_result.SetFailure(_cancel_order.status, ErrorCode.OrderNotFound); } } else { _json_result.SetFailure(); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Cancels an order you have placed in 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="order_id">Order number registered for sale or purchase</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 ValueTask <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, 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 _params = new Dictionary <string, object>(); { _params.Add("command", "cancelOrder"); _params.Add("currencyPair", _market.result.symbol); _params.Add("orderNumber", order_id); 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 _json_data = tradeClient.DeserializeObject <JToken>(_json_value.Content); { var _order = new MyOrderItem { orderId = order_id, symbol = _market.result.symbol, timestamp = CUnixTime.NowMilli, orderStatus = OrderStatus.Canceled, sideType = sideType, quantity = quantity, price = price, amount = quantity * price }; _result.result = _order; var _status = _json_data["success"].Value <int>() == 1; if (_status == false) { _json_result.SetFailure(); } } } _result.SetResult(_json_result); } else { _result.SetResult(_market); } return(_result); }
/// <summary> /// Submit a new Order /// </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> CreateMarketOrder(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) { if (args.ContainsKey("account-id") && args["account-id"].ToString() != "") { tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade); var _buy_sell = sideType == SideType.Bid ? "buy" : "sell"; var _params = new Dictionary <string, object>(); { _params.Add("account-id", args["account-id"].ToString()); _params.Add("amount", quantity.ToString()); //_params.Add("source", ); // 'api' for spot trade and 'margin-api' for margin trade _params.Add("symbol", _market.result.symbol); _params.Add("type", _buy_sell + "-market"); tradeClient.MergeParamsAndArgs(_params, args); } var _json_value = await tradeClient.CallApiPost1Async($"/v1/order/orders/place", _params); #if DEBUG _result.rawJson = _json_value.Content; #endif var _json_result = tradeClient.GetResponseMessage(_json_value.Response); if (_json_result.success == true) { var _order = tradeClient.DeserializeObject <HPlaceOrder>(_json_value.Content); { _order.result.orderType = OrderType.Market; //_order.result.price = price; _order.result.quantity = quantity; _order.result.sideType = sideType; _order.result.symbol = _market.result.symbol; _order.result.timestamp = CUnixTime.NowMilli; //_order.result.amount = (_order.result.quantity * _order.result.price).Normalize(); _order.result.fee = _order.result.amount * tradeClient.ExchangeInfo.Fees.trading.maker; _result.result = _order.result; } } _result.SetResult(_json_result); } else { _result.SetFailure("required args[account-id]"); } } else { _result.SetResult(_market); } return(_result); }