public async Task StartAsync()
{
Console.WriteLine($"Starting {Market}");
Strategy = new HoldUntilPriceDropsStrategy();
_traderGrain = _orleansClient.GetGrain <ITraderGrain>(Market);
await _traderGrain.SetMarketAsync(Market);
TraderState = await _traderGrain.GetTraderData();
TraderState.Trades = TraderState.Trades ?? new List <Trade>();
Strategy.Settings = TraderSettings.Default;
_lastCandleUpdateTime = DateTime.UtcNow;
var candlesResponse = await _cryptoApi.GetCandlesAsync(Market, TickInterval.OneHour);
_coinTrader.Candles = candlesResponse.Content;
Console.WriteLine($"Downloaded {candlesResponse.Content.Count} candles for {Market}");
if (TraderState.Trades.Count == 0)
{
TraderState.Trades.Add(new Trade {
Status = TradeStatus.Empty
});
}
_coinTrader.IsInTestMode = IsInTestMode;
_coinTrader.Initialize(TraderState);
CanUpdate = true;
if (!IsInTestMode)
{
await UpdateOrders();
}
}
public async Task <BackTestResult> TrySettings(string market, List <Candle> candlesContent, TraderSettings settings)
{
_market = market;
if (candlesContent == null)
{
_candles = (await _fakeBittrexApi.GetCandlesAsync((_market), TickInterval.OneMinute)).Content;
}
else
{
_candles = candlesContent;
}
var strategy = new HoldUntilPriceDropsStrategy {
Settings = settings
};
var coinTrader = await RunHistoryData(strategy);
var budget = await coinTrader.FinishTest();
var backTestResult = new BackTestResult
{
Budget = budget,
Settings = strategy.Settings
};
return(backTestResult);
}
public void Initialize(TraderState traderState)
{
Market = traderState.Market;
Strategy = new HoldUntilPriceDropsStrategy();
_cryptoApi.TickerUpdated
.Where(t => t.Market == traderState.Market)
.Select(ticker => Observable.FromAsync(token => UpdatePrice(ticker)))
.Concat()
.Subscribe(unit => { }, OnCompleted);
_cryptoApi.OrderUpdated
.Where(o => o.Market == traderState.Market)
.Select(order => Observable.FromAsync(token => UpdateOrder(order)))
.Concat()
.Subscribe();
TraderState = traderState;
Strategy.Settings = traderState.Settings ?? TraderSettings.Default;
if (TraderState.Trades.Count == 0)
{
TraderState.Trades.Add(new Trade {
Status = TradeStatus.Empty
});
}
}
public HoldUntilPriceDropsStrategyTests()
{
_strategy = new HoldUntilPriceDropsStrategy {
Settings = TraderSettings.Default
};
_strategy.Settings.HighStopLossPercentage = -5;
_strategy.Settings.StopLoss = -2;
_strategy.Settings.BuyTrigger = -1;
_currentTrade = new Trade
{
BuyOrder = new CryptoOrder
{
PricePerUnit = 100,
Uuid = "abc"
}
};
}
public void Initialize(string market)
{
_tickerIndex = 0;
Market = market;
Strategy = new HoldUntilPriceDropsStrategy();
_cryptoApi.TickerUpdated
.Where(t => t.Market == market)
.Select(ticker => Observable.FromAsync(token => UpdatePrice(ticker)))
.Concat()
.Subscribe(unit => { }, OnCompleted);
_cryptoApi.OrderUpdated
.Where(o => o.Market == market)
.Select(order => Observable.FromAsync(token => UpdateOrder(order)))
.Concat()
.Subscribe();
}
public async Task StartAsync()
{
Strategy = new HoldUntilPriceDropsStrategy();
_traderGrain = _orleansClient.GetGrain <ITraderGrain>(Market);
await _traderGrain.UpdateTrades(new List <Trade>());
await _traderGrain.SetMarketAsync(Market);
TraderState = await _traderGrain.GetTraderData();
TraderState.Trades = TraderState.Trades ?? new List <Trade>();
Strategy.Settings = TraderSettings.Default;
if (TraderState.Trades.Count == 0)
{
TraderState.Trades.Add(new Trade {
Status = TradeStatus.Empty
});
}
_cryptoBroker.Initialize(TraderState);
}
public async Task CheckProfit()
{
_candles = (await _fakeBittrexApi.GetCandlesAsync((_market), TickInterval.OneHour)).Content;
var strategy = new HoldUntilPriceDropsStrategy
{
Settings = new TraderSettings
{
BuyLowerPercentage = 0,
TradingBudget = 0.0012M,
MinimumTakeProfit = 0M,
HighStopLossPercentage = -0.001M,
StopLoss = -15,
BuyTrigger = -43M,
ExpirationTime = TimeSpan.FromHours(2)
}
};
var coinTrader = await RunHistoryData(strategy);
var budget = await coinTrader.FinishTest();
budget.Profit.Should().Be(5.86M);
}
public async Task <List <BackTestResult> > FindBestSettings(string market, List <Candle> candlesContent = null)
{
_market = market;
var candlesResponse = await _fakeBittrexApi.GetCandlesAsync(_market, TickInterval.OneHour);
_hourlyCandles = candlesResponse.Content;
if (candlesContent == null)
{
_candles = (await _fakeBittrexApi.GetCandlesAsync((_market), TickInterval.OneMinute)).Content;
}
else
{
_candles = candlesContent;
}
var firstOrderBuyLowerRange = new List <decimal> {
-1, 0
};
var buyLowerRange = new List <decimal> {
-3, -2, -1, -0.5M
};
var minimumTakeProfitRange = new List <decimal> {
0, 0.5M, 1
};
var highStopLossRange = new List <decimal> {
-10, -5, -1
};
var stopLossRange = new List <decimal> {
-25, -6, -4, -2
};
var buyTriggerRange = new List <decimal> {
-4, -2, -1
};
var expirationRange = new List <TimeSpan>
{
TimeSpan.FromHours(1),
TimeSpan.FromHours(24)
};
var it = 0;
var total = 0;
var bestProfit = -1000M;
var strategies = new List <HoldUntilPriceDropsStrategy>();
foreach (var firstBuy in firstOrderBuyLowerRange)
{
foreach (var buy in buyLowerRange)
{
foreach (var highStopLoss in highStopLossRange)
{
foreach (var stopLoss in stopLossRange)
{
foreach (var trigger in buyTriggerRange)
{
foreach (var expiration in expirationRange)
{
foreach (var minProfit in minimumTakeProfitRange)
{
if (stopLoss <= trigger)
{
continue;
}
total++;
var strategy = new HoldUntilPriceDropsStrategy();
strategy.Settings = new TraderSettings
{
FirstBuyLowerPercentage = firstBuy,
BuyLowerPercentage = buy,
HighStopLossPercentage = highStopLoss,
StopLoss = stopLoss,
BuyTrigger = trigger,
MinimumTakeProfit = minProfit,
TradingBudget = TraderSettings.Default.TradingBudget,
ExpirationTime = expiration
};
strategies.Add(strategy);
}
}
}
}
}
}
}
int oldPercentage = -1;
var results = new List <BackTestResult>();
Parallel.ForEach(strategies.Take(1), (strategy) =>
{
try
{
it++;
strategy.Settings = TraderSettings.Default;
var coinTrader = RunHistoryData(strategy).Result;
var budget = coinTrader.FinishTest().Result;
var backTestResult = new BackTestResult
{
Budget = budget,
Settings = strategy.Settings
};
results.Add(backTestResult);
var percentage = (it * 100) / total;
if (percentage != oldPercentage)
{
oldPercentage = percentage;
if (bestProfit < budget.Profit)
{
bestProfit = budget.Profit;
}
Console.WriteLine($"Current iteration: {it}/{total}\t{percentage}%\t\t{bestProfit}%");
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
});
results = results.OrderByDescending(r => r.Budget.Profit).ToList();
var uniqueProfits = results.GroupBy(r => r.Budget.Profit).OrderByDescending(r => r.Key).Select(s => s.FirstOrDefault()).ToList();
Console.WriteLine($"{uniqueProfits.Count}/{results.Count}");
foreach (var result in uniqueProfits.Take(50))
{
Console.WriteLine($"{result.Budget.Profit}% - {result.Settings}\t{result.Budget.Invested}\t{result.Budget.Earned}");
}
return(uniqueProfits);
}
public async Task FindBestSettings()
{
_candles = (await _fakeBittrexApi.GetCandlesAsync((_market), TickInterval.OneHour)).Content;
var buyLowerRange = new List <decimal> {
-3, -2, -1, 0
};
var minimumTakeProfitRange = new List <decimal> {
0, 1
};
var highStopLossRange = new List <decimal> {
-5, -1, -0.1M, -0.001M
};
var stopLossRange = new List <decimal> {
-15, -6, -4,
};
var buyTriggerRange = new List <decimal> {
-4, -2
};
var expirationRange = new List <TimeSpan>
{
TimeSpan.FromMinutes(15),
TimeSpan.FromHours(1),
TimeSpan.FromHours(2),
TimeSpan.FromHours(24)
};
var bestSettings = TraderSettings.Default;
var bestProfit = -1000M;
var totalIterations = buyLowerRange.Count * highStopLossRange.Count * stopLossRange.Count *
buyTriggerRange.Count * minimumTakeProfitRange.Count;
var it = 0;
var strategies = new List <HoldUntilPriceDropsStrategy>();
foreach (var buy in buyLowerRange)
{
foreach (var highStopLoss in highStopLossRange)
{
foreach (var stopLoss in stopLossRange)
{
foreach (var trigger in buyTriggerRange)
{
foreach (var expiration in expirationRange)
{
foreach (var minProfit in minimumTakeProfitRange)
{
var strategy = new HoldUntilPriceDropsStrategy();
strategy.Settings = new TraderSettings
{
BuyLowerPercentage = buy,
HighStopLossPercentage = highStopLoss,
StopLoss = stopLoss,
BuyTrigger = trigger,
MinimumTakeProfit = minProfit,
TradingBudget = TraderSettings.Default.TradingBudget,
ExpirationTime = expiration
};
strategies.Add(strategy);
}
}
}
}
}
}
var dict = new Dictionary <string, Budget>();
var oldPercentage = -1;
var index = 1;
Parallel.ForEach(strategies.Take(1), (strategy) =>
{
try
{
/*strategy = new HoldUntilPriceDropsStrategy
* {
* Settings = new TraderSettings
* {
* BuyLowerPercentage = 0,
* TradingBudget = 0.0012M,
* MinimumTakeProfit = 0M,
* HighStopLossPercentage = -0.001M,
* StopLoss = -15,
* BuyTrigger = -43M,
* ExpirationTime = TimeSpan.FromHours(2)
* }
* };*/
var coinTrader = RunHistoryData(strategy).Result;
var budget = coinTrader.FinishTest().Result;
Debug.WriteLine($"Finished {index++}");
it++;
if (budget.Profit > bestProfit)
{
bestSettings = strategy.Settings;
bestProfit = budget.Profit;
}
dict[strategy.Settings.ToString()] = budget;
var percentage = (it * 100) / totalIterations;
if (percentage != oldPercentage)
{
oldPercentage = percentage;
Console.WriteLine($"{bestProfit}%\t\t{percentage}%\t\t{bestSettings.ToString()}");
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
});
var topSettings = dict.OrderByDescending(d => d.Value.Profit).Take(50).ToList();
foreach (var keyValuePair in topSettings)
{
Console.WriteLine($"{keyValuePair.Value.Profit}% - {keyValuePair.Key}\t{keyValuePair.Value.Invested}\t{keyValuePair.Value.Earned}");
}
Console.WriteLine($"Best settings {bestSettings.StopLoss}\t{bestProfit} BTC");
var trader = await RunHistoryData(new HoldUntilPriceDropsStrategy { Settings = bestSettings });
var traderBudget = await trader.FinishTest();
traderBudget.Profit.Should().Be(topSettings[0].Value.Profit);
}
public async Task <BacktestingStats> FindBestSettings(string market)
{
var candlesResponse = await _cryptoApi.GetCandlesAsync(market, TickInterval.OneMinute);
var candles = candlesResponse.Content;
var buyLowerRange = new List <decimal> {
-5, -4, -3, -2, -1
};
var minimumTakeProfitRange = new List <decimal> {
0, 0.1M, 0.5M, 3, 5
};
var highStopLossRange = new List <decimal> {
-30, -5, -4, -3, -2, -1, -0.1M
};
var stopLossRange = new List <decimal> {
-30, -20, -10, -5, -4, -3
};
var buyTriggerRange = new List <decimal> {
-7, -6, -5, -4, -3, -2
};
var bestSettings = TraderSettings.Default;
var bestProfit = -100M;
var totalIterations = buyLowerRange.Count * highStopLossRange.Count * stopLossRange.Count *
buyTriggerRange.Count * minimumTakeProfitRange.Count;
var it = 0;
var strategies = new List <HoldUntilPriceDropsStrategy>();
foreach (var buy in buyLowerRange)
{
foreach (var highStopLoss in highStopLossRange)
{
foreach (var stopLoss in stopLossRange)
{
foreach (var trigger in buyTriggerRange)
{
foreach (var minProfit in minimumTakeProfitRange)
{
var strategy = new HoldUntilPriceDropsStrategy();
strategy.Settings = new TraderSettings
{
BuyLowerPercentage = buy,
HighStopLossPercentage = highStopLoss,
StopLoss = stopLoss,
BuyTrigger = trigger,
MinimumTakeProfit = minProfit,
TradingBudget = TraderSettings.Default.TradingBudget
};
strategies.Add(strategy);
}
}
}
}
}
var dict = new Dictionary <string, CryptoTraderStats>();
var oldPercentage = -1;
Parallel.ForEach(strategies, (strategy) =>
{
try
{
var backtester = new CryptoTraderBacktester();
backtester.Strategy = strategy;
backtester.Candles = candles;
backtester.Initialize();
var cryptoTraderStats = backtester.StartFromFile(market);
it++;
if (cryptoTraderStats.Profit > bestProfit)
{
bestSettings = strategy.Settings;
bestProfit = cryptoTraderStats.Profit;
}
lock (_syncObject)
{
if (dict.Any(d => d.Key == strategy.Settings.ToString()))
{
if (dict[strategy.Settings.ToString()].Profit < cryptoTraderStats.Profit)
{
dict[strategy.Settings.ToString()] = cryptoTraderStats;
}
}
else
{
dict[strategy.Settings.ToString()] = cryptoTraderStats;
}
}
var percentage = (it * 100) / totalIterations;
if (percentage != oldPercentage)
{
oldPercentage = percentage;
Console.WriteLine($"{bestProfit}%\t\t{percentage}%\t\t{bestSettings.ToString()}");
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
});
var topSettings = dict.OrderByDescending(d => d.Value.Profit).Take(50).ToList();
foreach (var keyValuePair in topSettings)
{
Console.WriteLine($"{keyValuePair.Value.Profit}% - {keyValuePair.Key}\t{keyValuePair.Value.Opened}\\{keyValuePair.Value.Closed}\t{keyValuePair.Value.InvestedBTC}\t{keyValuePair.Value.CurrentBTC}");
}
Console.WriteLine($"Best settings {bestSettings.StopLoss}\t{bestProfit} BTC");
return(new BacktestingStats
{
Market = market,
TradingStrategy = new HoldUntilPriceDropsStrategy {
Settings = bestSettings
},
TraderStats = topSettings[0].Value,
TraderSettings = bestSettings
});
}
