/// <summary>
/// Check ETH, ETC, and KRW and BTC balances. Request or cancel BTC withdrawals.
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = new Dictionary <string, object>();
{
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 privateClient.CallApiGet1Async("/user/balances", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _balances = privateClient.DeserializeObject <Dictionary <string, KBalanceItem> >(_json_value.Content);
foreach (var _currency_id in _markets.CurrencyNames)
{
var _balance = _balances.Where(b => b.Key == _currency_id.Key).SingleOrDefault().Value;
if (_balance != null)
{
_balance.used = _balance.trade_in_use + _balance.withdrawal_in_use;
_balance.total = _balance.used + _balance.free;
_balance.currency = _currency_id.Value;
_result.result.Add(_balance);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// Get wallet information.
/// </summary>
/// <param name="args">Add additional attributes for each exchange: [walletId]</param>
/// <returns></returns>
public override async Task <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _wallet_id = __wallet_id;
var _params = new Dictionary <string, object>();
{
privateClient.MergeParamsAndArgs(_params, args);
if (_params.ContainsKey("walletId") == true)
{
_wallet_id = _params["walletId"].ToString();
_params.Remove("walletId");
}
}
var _json_value = await privateClient.CallApiGet1Async($"/wallets/{_wallet_id}", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = privateClient.DeserializeObject <TWalletItem>(_json_value.Content);
{
foreach (var _currency_id in _markets.CurrencyNames)
{
var _balance = _json_data.balances.Where(b => b.currency == _currency_id.Key).FirstOrDefault();
if (_balance == null)
{
continue;
}
_balance.currency = _currency_id.Value;
_balance.used = _balance.total - _balance.free;
_result.result.Add(_balance);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// Get your account's margin status.
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = new Dictionary <string, object>();
{
_params.Add("currency", "all");
privateClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await privateClient.CallApiGet1Async("/api/v1/user/margin", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = privateClient.DeserializeObject <List <BBalanceItem> >(_json_value.Content);
{
foreach (var _currency_id in _markets.CurrencyNames)
{
var _balances = _json_data.Where(b => b.currency == _currency_id.Key);
foreach (var _balance in _balances)
{
if (_currency_id.Value == "BTC")
{
var _multiplier = publicApi.publicClient.ExchangeInfo.GetAmountMultiplier("XBTUSD", 1.0m);
_balance.free = _balance.free / _multiplier;
_balance.total = _balance.total / _multiplier;
}
_balance.currency = _currency_id.Value;
_balance.used = _balance.total - _balance.free;
_result.result.Add(_balance);
}
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// Get account balance
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = new Dictionary <string, object>();
{
_params.Add("method", "getAccountInfo");
privateClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await privateClient.CallApiGet1Async($"/getAccountInfo", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = privateClient.DeserializeObject <ZBalances>(_json_value.Content);
{
foreach (var _currency_id in _markets.CurrencyNames)
{
var _balance = _json_data.result.Where(b => b.key == _currency_id.Key).SingleOrDefault();
{
var _balanceItem = new ZBalanceItem();
if (_balance != null)
{
_balance.total = _balance.free + _balance.used;
_balanceItem = _balance;
}
_balanceItem.currency = _currency_id.Value;
_result.result.Add(_balanceItem);
}
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// 전체 계좌 조회
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiPost1Async("/1/private/balances", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = privateClient.DeserializeObject <GBalances>(_json_value.Content);
{
foreach (var _currency_id in _markets.CurrencyNames)
{
var _balance = new GBalanceItem();
_balance.currency = _currency_id.Value;
if (_json_data.success == true)
{
if (_json_data.available.ContainsKey(_currency_id.Value))
{
_balance.free = _json_data.available[_currency_id.Value].Value <decimal>();
}
if (_json_data.locked.ContainsKey(_currency_id.Value))
{
_balance.used = _json_data.locked[_currency_id.Value].Value <decimal>();
}
_balance.total = _balance.free + _balance.used;
}
_result.result.Add(_balance);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// Get User Account Info
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Balances> FetchBalancesAsync(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarketsAsync();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiPost1Async("/userinfo.do", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = privateClient.DeserializeObject <JObject>(_json_value.Content);
{
var _balances = _json_data["info"]["funds"];
foreach (var _currency_id in _markets.CurrencyNames)
{
if (_balances["free"].SelectToken(_currency_id.Key) == null)
{
continue;
}
var _balance = new OBalanceItem
{
free = _balances["free"][_currency_id.Key].Value <decimal>(),
used = _balances["freezed"][_currency_id.Key].Value <decimal>()
};
_balance.currency = _currency_id.Value;
_balance.total = _balance.free + _balance.used;
_result.result.Add(_balance);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// Returns all of your balances, including available balance, balance on orders, and the estimated BTC value of your balance.
/// By default, this call is limited to your exchange account; set the "account" POST parameter to "all" to include your margin and lending accounts.
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = new Dictionary <string, object>();
{
_params.Add("command", "returnCompleteBalances");
_params.Add("account", "all");
privateClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await privateClient.CallApiPost1Async("", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _balances = privateClient.DeserializeObject <Dictionary <string, PBalanceItem> >(_json_value.Content);
{
foreach (var _currency_id in _markets.CurrencyNames)
{
if (_balances.ContainsKey(_currency_id.Key) == false)
{
continue;
}
var _balance = _balances[_currency_id.Key];
_balance.total = _balance.free + _balance.used;
_balance.currency = _currency_id.Value;
_result.result.Add(_balance);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// 전체 계좌 조회
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Balances> FetchBalancesAsync(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarketsAsync();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiGet1Async("/api/accounts/balance", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = privateClient.DeserializeObject <JObject>(_json_value.Content);
{
foreach (var _currency_id in _markets.CurrencyNames)
{
var _balance = new CBalanceItem();
_balance.currency = _currency_id.Value;
if (_json_data["success"].Value <bool>() == true)
{
if (_json_data.ContainsKey(_currency_id.Key))
{
_balance.free = _json_data[_currency_id.Key].Value <decimal>();
}
if (_json_data.ContainsKey(_currency_id.Key))
{
_balance.used = _json_data[$"{_currency_id.Key}_reserved"].Value <decimal>();
}
_balance.total = _balance.free + _balance.used;
}
_result.result.Add(_balance);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// This method returns the balance, available balance, daily withdrawal limit and maximum withdraw for every currency in your account.
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiPost1Async($"money/info", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = privateClient.DeserializeObject <JObject>(_json_value.Content);
{
var _balances = _json_data["data"]["Wallets"];
foreach (var _currency_id in _markets.CurrencyNames)
{
var _token = _balances.SelectToken(_currency_id.Key);
if (_token == null)
{
continue;
}
var _balance = new ABalanceItem
{
free = _token["Available_Balance"]["value"].Value <decimal>(),
total = _token["Balance"]["value"].Value <decimal>()
};
_balance.used = _balance.total - _balance.free;
_balance.currency = _currency_id.Value;
_result.result.Add(_balance);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// Get account balance
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiPost1Async("/0/private/Balance", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _balances = privateClient.DeserializeObject <KResponse <Dictionary <string, decimal> > >(_json_value.Content);
{
foreach (var _b in _balances.result)
{
// X-ISO4217-A3 standard currency codes
var _baseId = _b.Key;
if (_baseId.Substring(0, 1) == "X" || _baseId.Substring(0, 1) == "Z")
{
_baseId = _baseId.Substring(1, 3);
}
var _market = _markets.GetMarketByBaseId(_baseId);
var _base_name = _market != null ? _market.baseName : _baseId;
_result.result.Add(new BalanceItem
{
currency = _base_name,
free = _b.Value,
total = _b.Value
});
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// 전체 계좌 조회
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Balances> FetchBalancesAsync(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarketsAsync();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiPost1Async("/v1/userinfo.do", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = privateClient.DeserializeObject <OBalances>(_json_value.Content);
{
foreach (var _currency_id in _markets.CurrencyNames)
{
//var _borrow = _json_data.info.funds.borrow.Where(b => b.Key == _currency_id.Key).SingleOrDefault();
var _free = _json_data.info.funds.free.Where(b => b.Key == _currency_id.Key).SingleOrDefault();
var _freezed = _json_data.info.funds.freezed.Where(b => b.Key == _currency_id.Key).SingleOrDefault();
var _balance = new OBalanceItem
{
currency = _currency_id.Value,
free = _free.Value,
used = _freezed.Value,
total = _free.Value + _freezed.Value
};
if (_balance.total > 0)
{
_result.result.Add(_balance);
}
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// Get account balance
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Balances> FetchBalancesAsync(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarketsAsync();
if (_markets.success == true)
{
if (args.ContainsKey("account-id") && args["account-id"].ToString() != "")
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiGet1Async($"/v1/account/accounts/{args["account-id"].ToString()}/balance", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = privateClient.DeserializeObject <HBalances>(_json_value.Content);
{
foreach (var _currency_id in _markets.CurrencyNames)
{
var _balances = _json_data.result.Where(b => b.currency == _currency_id.Key);
foreach (var _balance in _balances)
{
_balance.currency = _currency_id.Value;
_balance.total = _balance.free + _balance.used;
_result.result.Add(_balance);
}
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetFailure("account-id required. args[account-id]");
}
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// ACCOUNT BALANCES
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiPost1Async("/v2/balance/", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _balances = privateClient.DeserializeObject <JToken>(_json_value.Content);
{
foreach (var _currency_id in _markets.CurrencyNames)
{
if (_balances.SelectToken($"{_currency_id.Key}_available") != null)
{
var _balance = new BBalanceItem
{
free = _balances[$"{_currency_id.Key}_available"].Value <decimal>(),
used = _balances[$"{_currency_id.Key}_reserved"].Value <decimal>()
};
_balance.currency = _currency_id.Value;
_balance.total = _balance.free + _balance.used;
_result.result.Add(_balance);
}
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
///
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Balances> FetchBalancesAsync(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarketsAsync();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiPost1Async("/v2/account/balance", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _balances = privateClient.DeserializeObject <Dictionary <string, JToken> >(_json_value.Content);
{
foreach (var _currency_id in _markets.CurrencyNames)
{
if (_balances.ContainsKey(_currency_id.Key) == false)
{
continue;
}
var _balance = privateClient.DeserializeObject <CBalanceItem>(_balances[_currency_id.Key].ToString());
if (_balance != null)
{
_balance.currency = _currency_id.Value;
_balance.used = _balance.total - _balance.free;
_result.result.Add(_balance);
}
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// Get current account information.
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiGet1Async("/account", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = privateClient.DeserializeObject <JObject>(_json_value.Content);
{
var _json_balances = privateClient.DeserializeObject <List <BBalanceItem> >(_json_data["balances"].ToString());
foreach (var _currency_id in _markets.CurrencyNames)
{
var _balances = _json_balances.Where(b => b.currency == _currency_id.Key);
foreach (var _balance in _balances)
{
_balance.currency = _currency_id.Value;
_balance.total = _balance.free + _balance.used;
_result.result.Add(_balance);
}
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// Used to retrieve all balances from your account.
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiPost1Async("/api/v1/fund/allAccount", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _balances = privateClient.DeserializeObject <BBalances>(_json_value.Content);
{
foreach (var _currency_id in _markets.CurrencyNames)
{
var _balance = _balances.result.Where(b => b.currency == _currency_id.Key).SingleOrDefault();
if (_balance != null)
{
//_balance.total = _balance.free + _balance.used;
_balance.currency = _currency_id.Value;
_result.result.Add(_balance);
}
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// bithumb 거래소 회원 지갑 정보
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = new Dictionary <string, object>();
{
_params.Add("currency", "ALL");
privateClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await privateClient.CallApiPost1Async("/info/balance", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = privateClient.DeserializeObject <BBalance>(_json_value.Content);
if (_json_data.success == true)
{
foreach (var _coin_id in _markets.CurrencyNames)
{
var _base_id = _coin_id.Key.ToLower();
if (_json_data.data.SelectToken($"total_{_base_id}") == null)
{
continue;
}
var _balance = new BBalanceItem()
{
currency = _coin_id.Value,
free = _json_data.data[$"available_{_base_id}"].Value <decimal>(),
used = _json_data.data[$"in_use_{_base_id}"].Value <decimal>(),
total = _json_data.data[$"total_{_base_id}"].Value <decimal>(),
misu = _json_data.data[$"misu_{_base_id}"].Value <decimal>(),
xcoin_last = (_base_id != "krw") ? _json_data.data[$"xcoin_last_{_base_id}"].Value <decimal>() : 0
};
_result.result.Add(_balance);
}
}
else
{
_json_result.SetResult(_json_data);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
