public ActionResult ExchangePairs(string exchange, string baseCurrency)
{
var result = new JArray();
var symbolArray = new JArray();
IExchangeAPI api = ExchangeAPI.GetExchangeAPI(exchange);
var exchangeCoins = api.GetSymbolsMetadataAsync().Result;
if (!String.IsNullOrEmpty(baseCurrency))
{
exchangeCoins = exchangeCoins.Where(e => e.BaseCurrency.ToLowerInvariant() == baseCurrency.ToLowerInvariant());
}
foreach (var coin in exchangeCoins)
{
symbolArray.Add(api.ExchangeSymbolToGlobalSymbol(coin.MarketName));
}
var baseCurrencyArray = new JArray();
var exchangeBaseCurrencies = api.GetSymbolsMetadataAsync().Result.Select(m => m.BaseCurrency).Distinct();
foreach (var currency in exchangeBaseCurrencies)
{
baseCurrencyArray.Add(currency);
}
result.Add(symbolArray);
result.Add(baseCurrencyArray);
return(new JsonResult(result));
}
public static void RunGetOrderHistory(Dictionary <string, string> dict)
{
RequireArgs(dict, "exchangeName", "marketSymbol");
string exchangeName = dict["exchangeName"];
IExchangeAPI api = ExchangeAPI.GetExchangeAPI(exchangeName);
string marketSymbol = dict["marketSymbol"];
Authenticate(api);
DateTime?startDate = null;
if (dict.ContainsKey("startDate"))
{
startDate = DateTime.Parse(dict["startDate"]).ToUniversalTime();
}
var completedOrders = api.GetCompletedOrderDetailsAsync(marketSymbol, startDate).Sync();
foreach (var completedOrder in completedOrders)
{
Console.WriteLine(completedOrder);
}
Console.Write("Press enter to exit..");
Console.ReadLine();
}
private async void FetchTickers()
{
if (!Created || string.IsNullOrWhiteSpace(cmbExchange.SelectedItem as string))
{
return;
}
this.UseWaitCursor = true;
try
{
var api = await ExchangeAPI.GetExchangeAPIAsync(cmbExchange.SelectedItem as string);
var tickers = await api.GetTickersAsync();
StringBuilder b = new StringBuilder();
foreach (var ticker in tickers)
{
b.AppendFormat("{0,-12}{1}\r\n", ticker.Key, ticker.Value);
}
textTickersResult.Text = b.ToString();
}
catch (Exception ex)
{
textTickersResult.Text = ex.ToString();
}
finally
{
Invoke(new Action(() => this.UseWaitCursor = false));
}
}
public static string MarketBuy(string symbol, decimal amount, decimal price, ExchangeAPI exchange)
{
var order = CreateOrder(true, amount, OrderType.Market, price, symbol);
var result = PlaceOrder(exchange, order);
return(result.ToString());
}
public async Task CurrenciesParsedCorrectly()
{
var requestMaker = Substitute.For <IAPIRequestMaker>();
var binance = await ExchangeAPI.GetExchangeAPIAsync <ExchangeBinanceAPI>();
binance.RequestMaker = requestMaker;
requestMaker.MakeRequestAsync("/capital/config/getall", ((ExchangeBinanceAPI)binance).BaseUrlSApi).Returns(Resources.BinanceGetAllAssets);
IReadOnlyDictionary <string, ExchangeCurrency> currencies = await binance.GetCurrenciesAsync();
currencies.Should().HaveCount(3);
currencies.TryGetValue("bnb", out ExchangeCurrency bnb).Should().BeTrue();
bnb.DepositEnabled.Should().BeFalse();
bnb.WithdrawalEnabled.Should().BeTrue();
bnb.MinConfirmations.Should().Be(30);
bnb.FullName.Should().Be("Binance Coin");
bnb.Name.Should().Be("BNB");
bnb.TxFee.Should().Be(0.006m);
bnb.CoinType.Should().Be("ETH");
bnb.BaseAddress.Should().BeNullOrEmpty("api does not provide this info");
currencies.TryGetValue("NEO", out ExchangeCurrency neo).Should().BeTrue();
neo.Name.Should().Be("NEO");
neo.FullName.Should().Be("NEO");
neo.DepositEnabled.Should().BeTrue();
neo.WithdrawalEnabled.Should().BeFalse();
neo.TxFee.Should().Be(0);
neo.MinConfirmations.Should().Be(5);
neo.CoinType.Should().Be("NEO");
}
private static void PerformTests(Dictionary <string, string> dict)
{
IExchangeAPI[] apis = ExchangeAPI.GetExchangeAPIDictionary().Values.ToArray();
foreach (IExchangeAPI api in apis)
{
// test all public API for each exchange
try
{
string symbol = GetSymbol(api);
IReadOnlyCollection <string> symbols = api.GetSymbols();
Assert(symbols != null && symbols.Count != 0 && symbols.Contains(symbol));
ExchangeTrade[] trades = api.GetHistoricalTrades(symbol).ToArray();
Assert(trades.Length != 0 && trades[0].Price > 0m && trades[0].Amount > 0m);
var book = api.GetOrderBook(symbol);
Assert(book.Asks.Count != 0 && book.Bids.Count != 0 && book.Asks[0].Amount > 0m &&
book.Asks[0].Price > 0m && book.Bids[0].Amount > 0m && book.Bids[0].Price > 0m);
trades = api.GetRecentTrades(symbol).ToArray();
Assert(trades.Length != 0 && trades[0].Price > 0m && trades[0].Amount > 0m);
var ticker = api.GetTicker(symbol);
Assert(ticker != null && ticker.Ask > 0m && ticker.Bid > 0m && ticker.Last > 0m &&
ticker.Volume != null && ticker.Volume.PriceAmount > 0m && ticker.Volume.QuantityAmount > 0m);
}
catch (Exception ex)
{
Console.WriteLine("Request failed, api: {0}, error: {1}", api, ex);
}
}
}
public string GlobalToExchangeSymbol(string exchange, string symbol)
{
IExchangeAPI api = ExchangeAPI.GetExchangeAPI(exchange);
string exchangeSymbol = api.GlobalMarketSymbolToExchangeMarketSymbolAsync(symbol).Result;
return(exchangeSymbol);
}
public Scanner(Settings settings)
{
_settings = settings;
switch (_settings.Exchange.ToLowerInvariant())
{
case "bitfinex":
_api = new ExchangeBitfinexAPI();
break;
case "bittrex":
_api = new ExchangeBittrexAPI();
break;
case "binance":
_api = new ExchangeBinanceAPI();
break;
case "kraken":
_api = new ExchangeKrakenAPI();
break;
default:
Console.WriteLine($"Unknown exchange:{_settings.Exchange}");
return;
}
_api.RateLimit = new RateGate(800, TimeSpan.FromSeconds(60d));
FindCoinsWithEnoughVolume();
}
public Trade_package(decimal _precent, string _currency, SymbolsDate _buySymbolsDate, SymbolsDate _sellSymbolsDate)
{
api = StaticVariables.api;
itsBuyArbitrage = true;
percent = _precent;
buySymbolsDate = _buySymbolsDate;
sellSymbolsDate = _sellSymbolsDate;
currency = _currency;
buySymbol = buySymbolsDate.symbole;
sellSymbol = sellSymbolsDate.symbole;
minAmountTrade = Math.Max(buySymbolsDate.MinAmount, sellSymbolsDate.MinAmount);
maxAmountTrade = WalletFunc.GetMaxAmountTrade(buySymbolsDate.orderTrade.request.Price, buySymbolsDate.payment);
maxAmountTrade = StaticVariables.api.ClampOrderQuantity(buySymbol, maxAmountTrade);
if (maxAmountTrade < minAmountTrade)
{
string warningMessage = String.Format("currency - {0}, buySymbol - {1}, buy.MinAmount - {2}, sellSymbols - {3}, sell.MinAmount- {4}, minAmountTrade - {5}, maxAmountTrade - {6}", currency, buySymbol, buySymbolsDate.MinAmount, sellSymbol, sellSymbolsDate.MinAmount, minAmountTrade, maxAmountTrade);
PrintTable.PrintConsole(warningMessage);
PrintFunc.AddLine(StaticVariables.pathWithDate + "WARNING_maxAmount.txt", warningMessage);
maxAmountTrade = minAmountTrade;
}
}
public static void RunGetHistoricalTrades(Dictionary <string, string> dict)
{
RequireArgs(dict, "exchangeName", "symbol");
string exchangeName = dict["exchangeName"];
IExchangeAPI api = ExchangeAPI.GetExchangeAPI(exchangeName);
string symbol = dict["symbol"];
Console.WriteLine("Showing historical trades for exchange {0}...", exchangeName);
DateTime?startDate = null;
DateTime?endDate = null;
if (dict.ContainsKey("startDate"))
{
startDate = DateTime.Parse(dict["startDate"]).ToUniversalTime();
}
if (dict.ContainsKey("endDate"))
{
endDate = DateTime.Parse(dict["endDate"]).ToUniversalTime();
}
api.GetHistoricalTrades((IEnumerable <ExchangeTrade> trades) =>
{
foreach (ExchangeTrade trade in trades)
{
Console.WriteLine("Trade at timestamp {0}: {1}/{2}/{3}", trade.Timestamp.ToLocalTime(), trade.Id, trade.Price, trade.Amount);
}
return(true);
}, symbol, startDate, endDate);
}
private static async Task RunWebSocket(Dictionary <string, string> dict, Func <IExchangeAPI, Task <IWebSocket> > func)
{
RequireArgs(dict, "exchangeName");
using (var api = ExchangeAPI.GetExchangeAPI(dict["exchangeName"]))
{
if (api == null)
{
throw new ArgumentException("Cannot find exchange with name {0}", dict["exchangeName"]);
}
try
{
Logger.Info("Connecting web socket to {0}...", api.Name);
using (var socket = await func(api))
{
SetWebSocketEvents(socket);
Console.WriteLine("Press any key to quit.");
Console.ReadKey();
}
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
}
/// <summary>
/// Loop through all exchanges, get a json string for all symbols
/// </summary>
/// <returns></returns>
private async Task <string> GetAllSymbolsJsonAsync()
{
Dictionary <string, string[]> allSymbols = new Dictionary <string, string[]>();
List <Task> tasks = new List <Task>();
foreach (ExchangeAPI api in ExchangeAPI.GetExchangeAPIs())
{
tasks.Add(Task.Run(async() =>
{
try
{
string[] symbols = (await api.GetMarketSymbolsAsync()).ToArray();
lock (allSymbols)
{
allSymbols[api.Name] = symbols;
}
}
catch (NotImplementedException)
{
}
catch (Exception ex)
{
Console.WriteLine("Failed to get symbols for {0}, error: {1}", api, ex);
}
}));
}
await Task.WhenAll(tasks);
return(JsonConvert.SerializeObject(allSymbols));
}
public OrderTrade(ExchangeOrderRequest _request)
{
done = false;
succsseTrade = false;
succsseFirstOrder = false;
itsCanAdded = true;
itsMinimumPrice = false;
itsCanRevnu = true;
itsCanUpdate = true;
itsOrderLeft = false;
itsFirstOrder = false;
amountFilled = 0;
AmountFilledDifferentOrderNumber = 0;
numUpdate = -1;
Request = _request;
decimal valueMaxOrMinPrice = _request.Price; // TO VIEW Since the default value transfer "by reference" we want to get here "by Value" because the _request.Price value Will change during the run when we update the Request
originalMaxOrMinPrice = valueMaxOrMinPrice;
maxOrMinPrice = valueMaxOrMinPrice;
newPrice = valueMaxOrMinPrice;
api = StaticVariables.api;
roundingPrice = StaticVariables.roundingPrice;
}
public string GlobalToExchangeSymbol(string exchange, string symbol)
{
IExchangeAPI api = ExchangeAPI.GetExchangeAPI(exchange.ToLower());
string exchangeSymbol = api.GlobalSymbolToExchangeSymbol(symbol);
return(exchangeSymbol);
}
private static void RunWebSocketTickers(Dictionary <string, string> dict)
{
using (var api = ExchangeAPI.GetExchangeAPI(dict["exchangeName"]))
{
if (api == null)
{
throw new ArgumentException("Cannot find exchange with name {0}", dict["exchangeName"]);
}
try
{
using (var socket = api.GetTickersWebSocket(freshTickers =>
{
foreach (KeyValuePair <string, ExchangeTicker> kvp in freshTickers)
{
Console.WriteLine($"market {kvp.Key}, ticker {kvp.Value}");
}
}))
{
Console.WriteLine("Press any key to quit.");
Console.ReadKey();
}
}
catch (Exception ex)
{
Console.WriteLine("Web socket error: " + ex);
}
}
}
private static void RunOrderBookWebSocket(Dictionary <string, string> dict)
{
RequireArgs(dict, "exchangeName");
var api = ExchangeAPI.GetExchangeAPI(dict["exchangeName"]);
if (api == null)
{
throw new ArgumentException("Cannot find exchange with name {0}", dict["exchangeName"]);
}
var apiSymbols = api.GetSymbols();
string[] symbols = dict["symbols"].Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
foreach (string symbol in symbols)
{
if (!apiSymbols.Contains(symbol))
{
throw new ArgumentException(string.Format("Symbol {0} does not exist in API {1}, valid symbols: {2}", symbol, api.Name, string.Join(",", apiSymbols.OrderBy(s => s))));
}
}
IDisposable socket = api.GetOrderBookWebSocket(message =>
{
//print the top bid and ask with amount
var topBid = message.Bids.FirstOrDefault();
var topAsk = message.Asks.FirstOrDefault();
Console.WriteLine($"[{message.Symbol}:{message.SequenceId}] {topBid.Value.Price} ({topBid.Value.Amount}) | {topAsk.Value.Price} ({topAsk.Value.Amount})");
}, symbols: symbols);
Console.WriteLine("Press any key to quit.");
Console.ReadKey();
socket.Dispose();
}
public static void RunGetHistoricalTrades(Dictionary <string, string> dict)
{
RequireArgs(dict, "exchangeName", "marketSymbol");
string exchangeName = dict["exchangeName"];
IExchangeAPI api = ExchangeAPI.GetExchangeAPI(exchangeName);
string marketSymbol = dict["marketSymbol"];
Console.WriteLine("Showing historical trades for exchange {0}...", exchangeName);
DateTime?startDate = null;
DateTime?endDate = null;
if (dict.ContainsKey("startDate"))
{
startDate = DateTime.Parse(dict["startDate"]).ToUniversalTime();
}
if (dict.ContainsKey("endDate"))
{
endDate = DateTime.Parse(dict["endDate"]).ToUniversalTime();
}
//api.GetHistoricalTradesAsync((List<ExchangeTrade> trades) =>
//{
// foreach (ExchangeTrade trade in trades)
// {
// Console.WriteLine("Trade at timestamp {0}: {1}/{2}/{3}", trade.DateTime.ToLocalTime(), trade.Id, trade.Price, trade.Amount);
// }
// return true;
//}, marketSymbol, startDate, endDate).Sync();
}
public static void RunGetMarketSymbols(Dictionary <string, string> dict)
{
RequireArgs(dict, "exchangeName");
using (var api = ExchangeAPI.GetExchangeAPI(dict["exchangeName"]))
{
if (api == null)
{
throw new ArgumentException("Cannot find exchange with name {0}", dict["exchangeName"]);
}
try
{
var marketSymbols = api.GetMarketSymbolsAsync().Sync();
foreach (var marketSymbol in marketSymbols)
{
Console.WriteLine(marketSymbol);
}
Console.WriteLine("Press any key to quit.");
Console.ReadKey();
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
}
public static async Task RunGetMarketSymbols(Dictionary <string, string> dict)
{
RequireArgs(dict, "exchangeName");
using (var api = ExchangeAPI.GetExchangeAPI(dict["exchangeName"]))
{
if (api == null)
{
throw new ArgumentException("Cannot find exchange with name {0}", dict["exchangeName"]);
}
try
{
var marketSymbols = await api.GetMarketSymbolsAsync();
foreach (var marketSymbol in marketSymbols)
{
Logger.Info(marketSymbol);
}
WaitForKey();
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
}
public static void RunGetCandles(Dictionary <string, string> dict)
{
RequireArgs(dict, "exchangeName", "marketSymbol");
using (var api = ExchangeAPI.GetExchangeAPI(dict["exchangeName"]))
{
if (api == null)
{
throw new ArgumentException("Cannot find exchange with name {0}", dict["exchangeName"]);
}
try
{
var marketSymbol = dict["marketSymbol"];
var candles = api.GetCandlesAsync(marketSymbol, 1800, DateTime.UtcNow.AddDays(-12), DateTime.UtcNow).Sync();
foreach (var candle in candles)
{
Console.WriteLine(candle);
}
Console.WriteLine("Press any key to quit.");
Console.ReadKey();
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
}
public static async Task RunGetCandles(Dictionary <string, string> dict)
{
RequireArgs(dict, "exchangeName", "marketSymbol");
using (var api = ExchangeAPI.GetExchangeAPI(dict["exchangeName"]))
{
if (api == null)
{
throw new ArgumentException("Cannot find exchange with name {0}", dict["exchangeName"]);
}
try
{
var marketSymbol = dict["marketSymbol"];
var candles = await api.GetCandlesAsync(marketSymbol, 1800, CryptoUtility.UtcNow.AddDays(-12), CryptoUtility.UtcNow);
foreach (var candle in candles)
{
Logger.Info(candle.ToString());
}
WaitForKey();
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
}
public BaseExchange BaseExchange(string exchange)
{
IExchangeAPI api = ExchangeAPI.GetExchangeAPI(exchange.ToLower());
var builder = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()).AddJsonFile("appsettings.json", optional: true);
IConfiguration configuration = builder.Build();
ExchangeOptions exchangeOptions = new ExchangeOptions();
exchangeOptions.Exchange = (Exchange)Enum.Parse(typeof(Exchange), exchange, true);
string apiKey;
string apiSecret;
//Check if there are multiple exchanges in config, else Fallback to single mode
if (configuration.GetSection("Exchanges").GetSection(exchange) != null)
{
apiKey = configuration.GetSection("Exchanges").GetSection(exchange).GetValue <string>("ApiKey");
apiSecret = configuration.GetSection("Exchanges").GetSection(exchange).GetValue <string>("ApiSecret");
}
else
{
apiKey = configuration.GetValue <string>("ApiKey");
apiSecret = configuration.GetValue <string>("ApiSecret");
}
exchangeOptions.Exchange = (Exchange)Enum.Parse(typeof(Exchange), exchange, true);
exchangeOptions.ApiKey = apiKey;
exchangeOptions.ApiSecret = apiSecret;
return(new BaseExchange(exchangeOptions));
}
public static string LimitSell(string symbol, decimal amount, decimal price, ExchangeAPI exchange)
{
var order = CreateOrder(false, amount, OrderType.Limit, price, symbol);
var result = PlaceOrder(new ExchangeBinanceAPI(), order);
return(result.ToString());
}
public ActionResult BacktesterResults(string exchange, string coinsToBuy, string baseCurrency, string candleSize = "5", string strategy = "all")
{
JObject strategies = new JObject();
List <string> coins = new List <string>();
if (String.IsNullOrEmpty(coinsToBuy))
{
IExchangeAPI api = ExchangeAPI.GetExchangeAPI(exchange.ToLower());
var exchangeCoins = api.GetSymbolsMetadataAsync().Result.Where(m => m.BaseCurrency == baseCurrency);
foreach (var coin in exchangeCoins)
{
coins.Add(api.ExchangeSymbolToGlobalSymbol(coin.MarketName));
}
}
else
{
Char delimiter = ',';
String[] coinsToBuyArray = coinsToBuy.Split(delimiter);
foreach (var coin in coinsToBuyArray)
{
coins.Add(coin.ToUpper());
}
}
var backtestOptions = new BacktestOptions
{
DataFolder = Global.DataPath,
Exchange = (Exchange)Enum.Parse(typeof(Exchange), exchange, true),
Coins = coins,
CandlePeriod = Int32.Parse(candleSize)
};
var cts = new CancellationTokenSource();
var parallelOptions = new ParallelOptions
{
CancellationToken = cts.Token,
MaxDegreeOfParallelism = Environment.ProcessorCount
};
Parallel.ForEach(BacktestFunctions.GetTradingStrategies(), parallelOptions, async tradingStrategy =>
{
if (strategy != "all")
{
var base64EncodedBytes = Convert.FromBase64String(strategy);
if (tradingStrategy.Name != Encoding.UTF8.GetString(base64EncodedBytes))
{
return;
}
}
var result = await BacktestFunctions.BackTestJson(tradingStrategy, backtestOptions, Global.DataStoreBacktest);
foreach (var item in result)
{
await Runtime.GlobalHubBacktest.Clients.All.SendAsync("Send", JsonConvert.SerializeObject(item));
}
});
return(new JsonResult(strategies));
}
public string GlobalToTradingViewSymbol(string exchange, string symbol)
{
//Trading view use same format as Binance -> BTC-ETH is ETHBTC
IExchangeAPI api = ExchangeAPI.GetExchangeAPI(exchange);
string exchangeSymbol = api.GlobalMarketSymbolToExchangeMarketSymbolAsync(symbol).Result;
return(exchangeSymbol);
}
public string GlobalToTradingViewSymbol(string exchange, string symbol)
{
//Trading view use same format as Binance -> BTC-ETH is ETHBTC
IExchangeAPI api = ExchangeAPI.GetExchangeAPI("binance");
string exchangeSymbol = api.GlobalSymbolToExchangeSymbol(symbol);
return(exchangeSymbol);
}
public void Dispose()
{
if (_api != null)
{
_api.Dispose();
_api = null;
}
}
private static void TestExchanges()
{
IExchangeAPI[] apis = ExchangeAPI.GetExchangeAPIDictionary().Values.ToArray();
foreach (IExchangeAPI api in apis)
{
// test all public API for each exchange
try
{
string symbol = GetSymbol(api);
IReadOnlyCollection <string> symbols = api.GetSymbols().ToArray();
Assert(symbols != null && symbols.Count != 0 && symbols.Contains(symbol, StringComparer.OrdinalIgnoreCase));
Console.WriteLine($"API {api.Name} GetSymbols OK (default: {symbol}; {symbols.Count} symbols)");
ExchangeTrade[] trades = api.GetHistoricalTrades(symbol).ToArray();
Assert(trades.Length != 0 && trades[0].Price > 0m && trades[0].Amount > 0m);
Console.WriteLine($"API {api.Name} GetHistoricalTrades OK ({trades.Length})");
var book = api.GetOrderBook(symbol);
Assert(book.Asks.Count != 0 && book.Bids.Count != 0 && book.Asks[0].Amount > 0m &&
book.Asks[0].Price > 0m && book.Bids[0].Amount > 0m && book.Bids[0].Price > 0m);
Console.WriteLine($"API {api.Name} GetOrderBook OK ({book.Asks.Count} asks, {book.Bids.Count} bids)");
trades = api.GetRecentTrades(symbol).ToArray();
Assert(trades.Length != 0 && trades[0].Price > 0m && trades[0].Amount > 0m);
Console.WriteLine($"API {api.Name} GetRecentTrades OK ({trades.Length} trades)");
var ticker = api.GetTicker(symbol);
Assert(ticker != null && ticker.Ask > 0m && ticker.Bid > 0m && ticker.Last > 0m &&
ticker.Volume != null && ticker.Volume.PriceAmount > 0m && ticker.Volume.QuantityAmount > 0m);
Console.WriteLine($"API {api.Name} GetTicker OK (ask: {ticker.Ask}, bid: {ticker.Bid}, last: {ticker.Last})");
try
{
var candles = api.GetCandles(symbol, 86400, DateTime.UtcNow.Subtract(TimeSpan.FromDays(7.0)), null).ToArray();
Assert(candles.Length != 0 && candles[0].ClosePrice > 0m && candles[0].HighPrice > 0m && candles[0].LowPrice > 0m && candles[0].OpenPrice > 0m &&
candles[0].HighPrice >= candles[0].LowPrice && candles[0].HighPrice >= candles[0].ClosePrice && candles[0].HighPrice >= candles[0].OpenPrice &&
!string.IsNullOrWhiteSpace(candles[0].Name) && candles[0].ExchangeName == api.Name && candles[0].PeriodSeconds == 86400 && candles[0].VolumePrice > 0.0 &&
candles[0].VolumeQuantity > 0.0 && candles[0].WeightedAverage >= 0m);
Console.WriteLine($"API {api.Name} GetCandles OK ({candles.Length})");
}
catch (NotSupportedException)
{
Console.WriteLine($"API {api.Name} GetCandles not supported");
}
catch (NotImplementedException)
{
Console.WriteLine($"API {api.Name} GetCandles not implemented");
}
}
catch (Exception ex)
{
Console.WriteLine("Request failed, api: {0}, error: {1}", api, ex.Message);
}
}
}
protected override async void OnShown(EventArgs e)
{
base.OnShown(e);
foreach (var exchange in await ExchangeAPI.GetExchangeAPIsAsync())
{
cmbExchange.Items.Add(exchange.Name);
}
cmbExchange.SelectedIndex = 0;
}
public Engine()
{
api = new ExchangeBinanceUSAPI();
// load in the api keys.
api.LoadAPIKeysUnsecure(ConfigurationManager.AppSettings.Get("PublicKey"), ConfigurationManager.AppSettings.Get("SecretKey"));
logger.Trace($"Starting {QUOTECURRENCY} trading. LiveTrading={isLiveTrading}, StakeSize={stakeSize}, LowWaterMark={balanceLowWaterMark}");
}
