/// <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);
}