/// <summary>
/// Fetch symbols, market ids and exchanger's information
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Markets> FetchMarkets(Dictionary <string, object> args = null)
{
var _result = new Markets(true);
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
{
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value_jp = await publicClient.CallApiGet1Async("/v1/getmarkets", _params);
var _json_result_jp = publicClient.GetResponseMessage(_json_value_jp.Response);
if (_json_result_jp.success == true)
{
var _json_data_jp = publicClient.DeserializeObject <List <JObject> >(_json_value_jp.Content);
#if DEBUG
if (XApiClient.TestXUnitMode == XUnitMode.UseExchangeServer)
{
#endif
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _json_value_us = await publicClient.CallApiGet1Async("/v1/getmarkets/usa", _params);
var _json_result_us = publicClient.GetResponseMessage(_json_value_us.Response);
if (_json_result_us.success == true)
{
var _json_data_us = publicClient.DeserializeObject <List <JObject> >(_json_value_us.Content);
_json_data_jp = _json_data_jp.Concat(_json_data_us).ToList();
}
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
var _json_value_eu = await publicClient.CallApiGet1Async("/v1/getmarkets/eu", _params);
var _json_result_eu = publicClient.GetResponseMessage(_json_value_eu.Response);
if (_json_result_eu.success == true)
{
var _json_data_eu = publicClient.DeserializeObject <List <JObject> >(_json_value_eu.Content);
_json_data_jp = _json_data_jp.Concat(_json_data_eu).ToList();
}
#if DEBUG
}
#endif
foreach (var _market in _json_data_jp)
{
var _symbol = _market["product_code"].ToString();
var _currencies = _symbol.Split('_');
if (_currencies.Length != 2)
{
continue;
}
var _base_id = _currencies[0];
var _quote_id = _currencies[1];
var _base_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_base_id);
var _quote_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_quote_id);
var _market_id = _base_name + "/" + _quote_name;
var _precision = new MarketPrecision
{
amount = 8,
quantity = 8,
price = 8
};
var _limits = new MarketLimits
{
amount = new MarketMinMax
{
max = decimal.MaxValue,
min = 0
},
price = new MarketMinMax
{
max = decimal.MaxValue,
min = 0
},
quantity = new MarketMinMax
{
max = decimal.MaxValue,
min = 0
}
};
var _entry = new MarketItem
{
marketId = _market_id,
symbol = _symbol,
baseId = _base_id,
quoteId = _quote_id,
baseName = _base_name,
quoteName = _quote_name,
lot = 0,
active = true,
precision = _precision,
limits = _limits
};
_result.result.Add(_entry.marketId, _entry);
}
}
else
{
_result.SetResult(_json_result_jp);
}
}
return(_result);
}
/// <summary>
/// Fetch symbols, market ids and exchanger's information
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Markets> FetchMarkets(Dictionary <string, object> args = null)
{
var _result = new Markets();
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
{
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value = await publicClient.CallApiGet1Async("/exchangeInfo", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _exchange_info = publicClient.DeserializeObject <JObject>(_json_value.Content);
var _symbols = _exchange_info["symbols"].ToObject <JArray>();
foreach (var _market in _symbols)
{
var _symbol = _market["symbol"].ToString();
if (_symbol == "123456") // "123456" is a "test symbol/market"
{
continue;
}
var _base_id = _market["baseAsset"].ToString();
var _quote_id = _market["quoteAsset"].ToString();
var _base_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_base_id);
var _quote_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_quote_id);
var _market_id = _base_name + "/" + _quote_name;
var _precision = new MarketPrecision
{
quantity = _market["baseAssetPrecision"].Value <int>(),
price = _market["quotePrecision"].Value <int>(),
amount = _market["quotePrecision"].Value <int>()
};
var _lot = (decimal)(-1.0 * Math.Log10(_precision.quantity));
var _active = _market["status"].ToString().ToUpper() == "TRADING";
var _limits = new MarketLimits
{
quantity = new MarketMinMax
{
min = (decimal)Math.Pow(10, -_precision.quantity),
max = decimal.MaxValue
},
price = new MarketMinMax
{
min = (decimal)Math.Pow(10, -_precision.price),
max = decimal.MaxValue
},
amount = new MarketMinMax
{
min = _lot,
max = decimal.MaxValue
}
};
var _entry = new MarketItem
{
marketId = _market_id,
symbol = _symbol,
baseId = _base_id,
quoteId = _quote_id,
baseName = _base_name,
quoteName = _quote_name,
lot = _lot,
active = _active,
precision = _precision,
limits = _limits
};
var _filters = _market["filters"];
{
var _price_filter = _filters.SingleOrDefault(f => f["filterType"].ToString() == "PRICE_FILTER");
if (_price_filter != null)
{
_entry.precision.price = Numerical.PrecisionFromString(_price_filter["tickSize"].ToString());
_entry.limits.price.min = _price_filter["minPrice"].Value <decimal>();
_entry.limits.price.max = _price_filter["maxPrice"].Value <decimal>();
}
var _lot_size = _filters.SingleOrDefault(f => f["filterType"].ToString() == "LOT_SIZE");
if (_lot_size != null)
{
_entry.precision.quantity = Numerical.PrecisionFromString(_lot_size["stepSize"].ToString());
_entry.limits.quantity.min = _lot_size["minQty"].Value <decimal>();
_entry.limits.quantity.max = _lot_size["maxQty"].Value <decimal>();
}
var _min_notional = _filters.SingleOrDefault(f => f["filterType"].ToString() == "MIN_NOTIONAL");
if (_min_notional != null)
{
_entry.limits.amount.min = _min_notional["minNotional"].Value <decimal>();
}
}
_result.result.Add(_entry.marketId, _entry);
}
}
_result.SetResult(_json_result);
}
return(_result);
}
/// <summary>
/// Fetch symbols, market ids and exchanger's information
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Markets> FetchMarkets(Dictionary <string, object> args = null)
{
var _result = new Markets();
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
{
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value = await publicClient.CallApiGet1Async("/currency_limits", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <JObject>(_json_value.Content);
var _pairs = _json_data["data"]["pairs"];
foreach (var _market in _pairs)
{
var _base_id = _market["symbol1"].ToString();
var _quote_id = _market["symbol2"].ToString();
var _symbol = _base_id + "/" + _quote_id;
var _base_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_base_id);
var _quote_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_quote_id);
var _market_id = _base_name + "/" + _quote_name;
var _lot = _market["minLotSize"].Value <decimal>();
var _maxLot = (_market["maxLotSize"].HasValues) ? _market["maxLotSize"].Value <decimal>() : decimal.MaxValue;
var _precision = new MarketPrecision
{
quantity = (int)(-1 * Math.Log10((double)_lot)),
price = Numerical.PrecisionFromString(_market["minPrice"].Value <string>()),
amount = Numerical.PrecisionFromString(_market["minPrice"].Value <string>())
};
var _limits = new MarketLimits
{
quantity = new MarketMinMax
{
min = _market["minLotSize"].Value <decimal>(),
max = _maxLot
},
price = new MarketMinMax
{
min = _market["minPrice"].Value <decimal>(),
max = _market["maxPrice"].Value <decimal>()
},
amount = new MarketMinMax
{
min = _market["minLotSizeS2"].Value <decimal>(),
max = decimal.MaxValue
}
};
var _entry = new MarketItem
{
marketId = _market_id,
symbol = _symbol,
baseId = _base_id,
quoteId = _quote_id,
baseName = _base_name,
quoteName = _quote_name,
lot = _lot,
active = true,
precision = _precision,
limits = _limits
};
_result.result.Add(_entry.marketId, _entry);
}
}
_result.SetResult(_json_result);
}
return(_result);
}
/// <summary>
/// Fetch symbols, market ids and exchanger's information
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Markets> FetchMarkets(Dictionary <string, object> args = null)
{
var _result = new Markets();
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
{
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value = await publicClient.CallApiGet1Async("/v1/symbols_details", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _symbols = publicClient.DeserializeObject <JArray>(_json_value.Content);
foreach (var _market in _symbols)
{
var _symbol = _market["pair"].ToString();
var _base_id = _symbol.Substring(0, 3);
var _quote_id = _symbol.Substring(3);
var _base_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_base_id);
var _quote_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_quote_id);
var _market_id = _base_name + "/" + _quote_name;
var _precision = new MarketPrecision
{
quantity = _market["price_precision"].Value <int>(),
price = _market["price_precision"].Value <int>(),
amount = _market["price_precision"].Value <int>()
};
var _lot = (decimal)Math.Pow(10.0, -_precision.price);
var _limits = new MarketLimits
{
quantity = new MarketMinMax
{
min = _market["minimum_order_size"].Value <decimal>(),
max = _market["maximum_order_size"].Value <decimal>()
},
price = new MarketMinMax
{
min = (decimal)Math.Pow(10.0, -_precision.price),
max = (decimal)Math.Pow(10.0, _precision.price)
}
};
_limits.amount = new MarketMinMax
{
min = _limits.quantity.min * _limits.price.min,
max = decimal.MaxValue
};
var _entry = new MarketItem
{
marketId = _market_id,
symbol = _symbol,
baseId = _base_id,
quoteId = _quote_id,
baseName = _base_name,
quoteName = _quote_name,
lot = _lot,
active = true,
precision = _precision,
limits = _limits
};
_result.result.Add(_entry.marketId, _entry);
}
}
_result.SetResult(_json_result);
}
return(_result);
}
/// <summary>
/// Fetch symbols, market ids and exchanger's information
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Markets> FetchMarketsAsync(Dictionary <string, object> args = null)
{
var _result = new Markets();
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
{
var _params = new Dictionary <string, object>();
{
_params.Add("command", "returnTicker");
publicClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await publicClient.CallApiGet1Async("", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _tickers = publicClient.DeserializeObject <JObject>(_json_value.Content);
foreach (var _market in _tickers)
{
var _symbol = _market.Key;
var _base_id = _symbol.Split('_')[1];
var _quote_id = _symbol.Split('_')[0];
var _base_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_base_id);
var _quote_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_quote_id);
var _market_id = _base_name + "/" + _quote_name;
var _precision = new MarketPrecision
{
quantity = 8,
price = 8,
amount = 8
};
var _lot = (decimal)Math.Pow(10.0, -(double)_precision.price);
var _active = true;
var _limits = new MarketLimits
{
quantity = new MarketMinMax
{
min = 0.00000001m,
max = 1000000000m
},
price = new MarketMinMax
{
min = 0.00000001m,
max = 1000000000m
},
amount = new MarketMinMax
{
min = 0.00000000m,
max = 1000000000m
}
};
_result.result.Add(_market_id, new MarketItem
{
marketId = _market_id,
symbol = _symbol,
baseId = _base_id,
quoteId = _quote_id,
baseName = _base_name,
quoteName = _quote_name,
lot = _lot,
active = _active,
precision = _precision,
limits = _limits
});
}
}
_result.SetResult(_json_result);
}
return(_result);
}
/// <summary>
/// Fetch symbols, market ids and exchanger's information
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Markets> FetchMarkets(Dictionary <string, object> args = null)
{
var _result = new Markets();
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
{
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value = await publicClient.CallApiGet1Async("/v2/trading-pairs-info/", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _pairs_info = publicClient.DeserializeObject <List <JObject> >(_json_value.Content);
foreach (var _market in _pairs_info)
{
var _symbol = _market["url_symbol"].ToString();
var _market_name = _market["name"].ToString().Split('/');
var _base_id = _market_name[0].ToLower();
var _quote_id = _market_name[1].ToLower();
var _base_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_base_id);
var _quote_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_quote_id);
var _market_id = _base_name + "/" + _quote_name;
var _precision = new MarketPrecision
{
quantity = _market["base_decimals"].Value <int>(),
price = _market["counter_decimals"].Value <int>(),
amount = _market["counter_decimals"].Value <int>()
};
var _lot = (decimal)Math.Pow(10, -_precision.quantity);
var _active = _market["trading"].ToString().ToLower() == "enabled";
var _limits = new MarketLimits
{
quantity = new MarketMinMax
{
min = _lot,
max = decimal.MaxValue
},
price = new MarketMinMax
{
min = (decimal)Math.Pow(10, -_precision.price),
max = decimal.MaxValue
},
amount = new MarketMinMax
{
min = Convert.ToDecimal(_market["minimum_order"].Value <string>().Split(' ')[0]),
max = decimal.MaxValue
}
};
var _entry = new MarketItem
{
marketId = _market_id,
symbol = _symbol,
baseId = _base_id,
quoteId = _quote_id,
baseName = _base_name,
quoteName = _quote_name,
lot = _lot,
active = _active,
precision = _precision,
limits = _limits
};
_result.result.Add(_entry.marketId, _entry);
}
}
_result.SetResult(_json_result);
}
return(_result);
}
/// <summary>
/// Fetch symbols, market ids and exchanger's information
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Markets> FetchMarketsAsync(Dictionary <string, object> args = null)
{
var _result = new Markets();
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
{
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value = await publicClient.CallApiGet1Async("/products", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _products = publicClient.DeserializeObject <List <JObject> >(_json_value.Content);
foreach (var _market in _products)
{
var _symbol = _market["id"].ToString();
var _base_id = _market["base_currency"].ToString();
var _quote_id = _market["quote_currency"].ToString();
var _base_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_base_id);
var _quote_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_quote_id);
var _market_id = _base_name + "/" + _quote_name;
var _precision = new MarketPrecision
{
quantity = 8,
price = Numerical.PrecisionFromString(_market["quote_increment"].Value <string>()),
amount = 0
};
var _lot = (decimal)Math.Pow(10, -(double)_precision.quantity);
var _active = _market["status"].ToString() == "online";
var _limits = new MarketLimits
{
quantity = new MarketMinMax
{
min = _market["base_min_size"].Value <decimal>(),
max = _market["base_max_size"].Value <decimal>()
},
price = new MarketMinMax
{
min = _market["quote_increment"].Value <decimal>(),
max = decimal.MaxValue
},
amount = new MarketMinMax
{
min = _market["min_market_funds"].Value <decimal>(),
max = _market["max_market_funds"].Value <decimal>()
}
};
var _entry = new MarketItem
{
marketId = _market_id,
symbol = _symbol,
baseId = _base_id,
quoteId = _quote_id,
baseName = _base_name,
quoteName = _quote_name,
lot = _lot,
active = _active,
precision = _precision,
limits = _limits
};
_result.result.Add(_entry.marketId, _entry);
}
}
_result.SetResult(_json_result);
}
return(_result);
}
/// <summary>
/// Fetch symbols, market ids and exchanger's information
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Markets> FetchMarkets(Dictionary <string, object> args = null)
{
var _result = new Markets();
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
{
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value = await publicClient.CallApiGet1Async("/constants", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <JObject>(_json_value.Content);
var _contants = _json_data["exchange"].ToObject <JObject>();
foreach (var _market in _contants)
{
var _symbol = _market.Key;
var _base_id = _symbol.Split('_')[0];
var _quote_id = _symbol.Split('_')[1];
var _base_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_base_id);
var _quote_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_quote_id);
var _market_id = _base_name + "/" + _quote_name;
var _precision = new MarketPrecision
{
quantity = 8,
price = 0,
amount = 0
};
var _lot = _market.Value["tick_size"].Value <decimal>();
var _limits = new MarketLimits
{
quantity = new MarketMinMax
{
min = _market.Value["order_min_size"].Value <decimal>(),
max = _market.Value["order_max_size"].Value <decimal>()
},
price = new MarketMinMax
{
min = _market.Value["min_price"].Value <decimal>(),
max = _market.Value["max_price"].Value <decimal>()
}
};
_limits.amount = new MarketMinMax
{
min = _limits.quantity.min * _limits.price.min,
max = _limits.quantity.max * _limits.price.max
};
var _entry = new MarketItem
{
marketId = _market_id,
symbol = _symbol,
baseId = _base_id,
quoteId = _quote_id,
baseName = _base_name,
quoteName = _quote_name,
lot = _lot,
active = true,
precision = _precision,
limits = _limits
};
_result.result.Add(_entry.marketId, _entry);
}
}
_result.SetResult(_json_result);
}
return(_result);
}
/// <summary>
/// Fetch symbols, market ids and exchanger's information
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task<Markets> FetchMarkets(Dictionary<string, object> args = null)
{
var _result = new Markets();
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
{
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value = await publicClient.CallApiGet1Async("/trading-pairs", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _pairs = publicClient.DeserializeObject<List<JObject>>(_json_value.Content);
foreach (var _market in _pairs)
{
var _symbol = _market["name"].ToString();
var _base_id = _market["baseAsset"].ToString();
var _quote_id = _market["quoteAsset"].ToString();
var _base_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_base_id);
var _quote_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_quote_id);
var _market_id = _base_name + "/" + _quote_name;
var _precision = new MarketPrecision
{
quantity = 4,
price = 0,
amount = 0
};
var _lot = 0.1m;
var _active = true;
var _limits = new MarketLimits
{
quantity = new MarketMinMax
{
min = (decimal)Math.Pow(10, -_precision.quantity),
max = decimal.MaxValue
},
price = new MarketMinMax
{
min = (decimal)Math.Pow(10, -_precision.price),
max = decimal.MaxValue
},
amount = new MarketMinMax
{
min = _lot,
max = decimal.MaxValue
}
};
var _entry = new MarketItem
{
marketId = _market_id,
symbol = _symbol,
baseId = _base_id,
quoteId = _quote_id,
baseName = _base_name,
quoteName = _quote_name,
lot = _lot,
active = _active,
precision = _precision,
limit = _limits
};
_result.result.Add(_entry.marketId, _entry);
}
}
_result.SetResult(_json_result);
}
return _result;
}
/// <summary>
/// Fetch symbols, market ids and exchanger's information
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Markets> FetchMarketsAsync(Dictionary <string, object> args = null)
{
var _result = new Markets();
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
{
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value = await publicClient.CallApiGet1Async("/products", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _products = publicClient.DeserializeObject <List <JObject> >(_json_value.Content);
foreach (var _market in _products)
{
var _symbol = _market["id"].ToString();
var _base_id = _market["base_currency"].ToString();
var _quote_id = _market["quoted_currency"].ToString();
var _base_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_base_id);
var _quote_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_quote_id);
var _market_id = _base_name + "/" + _quote_name;
var _makerFee = _market["maker_fee"].Value <decimal>();
var _takerFee = _market["taker_fee"].Value <decimal>();
var _minQuantity = 0m;
if (_base_id == "BTC")
{
_minQuantity = 0.001m;
}
else if (_base_id == "ETH")
{
_minQuantity = 0.01m;
}
var _minPrice = 0m;
if (_quote_id == "BTC")
{
_minPrice = 0.00000001m;
}
else if (_quote_id == "ETH" || _quote_id == "USD" || _quote_id == "JPY")
{
_minPrice = 0.00001m;
}
var _minAmount = 0m;
if (_minPrice != 0 && _minQuantity != 0)
{
_minAmount = _minQuantity * _minPrice;
}
var _precision_quantity = (_minQuantity != 0) ? -1 * (int)Math.Log10((double)_minQuantity) : 0;
var _precision_price = (_minPrice != 0) ? -1 * (int)Math.Log10((double)_minPrice) : 0;
var _precision = new MarketPrecision
{
quantity = _precision_quantity,
price = _precision_price,
amount = _precision_price
};
var _lot = (decimal)Math.Pow(10, -_precision_price);
var _active = _market["disabled"].Value <bool>() == false;
var _limits = new MarketLimits
{
quantity = new MarketMinMax
{
min = _minQuantity, // minAmount
max = decimal.MaxValue
},
price = new MarketMinMax
{
min = _minPrice,
max = decimal.MaxValue
},
amount = new MarketMinMax
{
min = _minAmount,
max = decimal.MaxValue
}
};
var _entry = new MarketItem
{
marketId = _market_id,
symbol = _symbol,
baseId = _base_id,
quoteId = _quote_id,
baseName = _base_name,
quoteName = _quote_name,
lot = _lot,
active = _active,
makerFee = _makerFee,
takerFee = _takerFee,
precision = _precision,
limits = _limits
};
_result.result.Add(_entry.marketId, _entry);
}
}
_result.SetResult(_json_result);
}
return(_result);
}
/// <summary>
/// Fetch symbols, market ids and exchanger's information
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Markets> FetchMarkets(Dictionary <string, object> args = null)
{
var _result = new Markets();
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
{
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value = await publicClient.CallApiGet1Async("/ticker/ALL", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = publicClient.DeserializeObject <JObject>(_json_value.Content);
var _tickers = _json_data["data"].ToObject <JObject>();
foreach (var _market in _tickers)
{
var _symbol = _market.Key;
if (_symbol == "date")
{
continue;
}
var _base_id = _symbol.ToLower();
var _quote_id = "krw";
var _base_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_base_id);
var _quote_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_quote_id);
var _market_id = _base_name + "/" + _quote_name;
var _precision = new MarketPrecision
{
quantity = 8,
price = 0,
amount = 0
};
var _lot = (decimal)Math.Pow(10.0, -_precision.price);
var _limits = new MarketLimits
{
quantity = new MarketMinMax
{
min = 0,
max = decimal.MaxValue
},
price = new MarketMinMax
{
min = 0,
max = decimal.MaxValue
},
amount = new MarketMinMax
{
min = 0,
max = decimal.MaxValue
}
};
var _entry = new MarketItem
{
marketId = _market_id,
symbol = _symbol,
baseId = _base_id,
quoteId = _quote_id,
baseName = _base_name,
quoteName = _quote_name,
lot = _lot,
active = true,
precision = _precision,
limits = _limits
};
_result.result.Add(_entry.marketId, _entry);
}
}
_result.SetResult(_json_result);
}
return(_result);
}
/// <summary>
/// Fetch symbols, market ids and exchanger's information
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Markets> FetchMarketsAsync(Dictionary <string, object> args = null)
{
var _result = new Markets();
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
{
var _params = publicClient.MergeParamsAndArgs(args);
var _json_value = await publicClient.CallApiGet1Async("/v1/symbols", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _symbols = publicClient.DeserializeObject <JArray>(_json_value.Content);
foreach (var _market in _symbols)
{
var _symbol = _market.ToString();
var _base_id = _symbol.Substring(0, 3);
var _quote_id = _symbol.Substring(3);
var _base_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_base_id);
var _quote_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_quote_id);
var _market_id = _base_name + "/" + _quote_name;
var _precision = new MarketPrecision
{
quantity = 8,
price = 8,
amount = 8
};
var _lot = (decimal)(-1.0 * Math.Log10((double)_precision.quantity));
var _active = true;
var _limits = new MarketLimits
{
quantity = new MarketMinMax
{
min = (decimal)Math.Pow(10.0, -(double)_precision.quantity),
max = decimal.MaxValue
},
price = new MarketMinMax
{
min = (decimal)Math.Pow(10.0, -(double)_precision.price),
max = decimal.MaxValue
},
amount = new MarketMinMax
{
min = _lot,
max = decimal.MaxValue
}
};
var _entry = new MarketItem
{
marketId = _market_id,
symbol = _symbol,
baseId = _base_id,
quoteId = _quote_id,
baseName = _base_name,
quoteName = _quote_name,
lot = _lot,
active = _active,
precision = _precision,
limits = _limits
};
_result.result.Add(_entry.marketId, _entry);
}
}
_result.SetResult(_json_result);
}
return(_result);
}
/// <summary>
/// Fetch symbols, market ids and exchanger's information
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Markets> FetchMarkets(Dictionary <string, object> args = null)
{
var _result = new Markets();
publicClient.ExchangeInfo.ApiCallWait(TradeType.Public);
{
var _params = new Dictionary <string, object>();
{
_params.Add("currency", "all");
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 publicClient.CallApiGet1Async("/ticker", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = publicClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _tickers = publicClient.DeserializeObject <Dictionary <string, JToken> >(_json_value.Content);
foreach (var _market in _tickers)
{
if (_market.Value.GetType() == typeof(JValue))
{
continue;
}
var _symbol = _market.Key;
var _base_id = _market.Key;
var _quote_id = "krw";
var _base_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_base_id);
var _quote_name = publicClient.ExchangeInfo.GetCommonCurrencyName(_quote_id);
var _market_id = _base_name + "/" + _quote_name;
var _precision = new MarketPrecision
{
quantity = 4,
price = 0,
amount = 0
};
var _lot = 0.1m;
var _active = true;
var _limits = new MarketLimits
{
quantity = new MarketMinMax
{
min = (decimal)Math.Pow(10, -_precision.quantity),
max = decimal.MaxValue
},
price = new MarketMinMax
{
min = (decimal)Math.Pow(10, -_precision.price),
max = decimal.MaxValue
},
amount = new MarketMinMax
{
min = _lot,
max = decimal.MaxValue
}
};
var _entry = new MarketItem
{
marketId = _market_id,
symbol = _symbol,
baseId = _base_id,
quoteId = _quote_id,
baseName = _base_name,
quoteName = _quote_name,
lot = _lot,
active = _active,
precision = _precision,
limits = _limits
};
_result.result.Add(_entry.marketId, _entry);
}
}
_result.SetResult(_json_result);
}
return(_result);
}
