/// <summary>
/// Checks our current running trades against the strategy.
/// If the strategy tells us to sell we need to do so.
/// </summary>
/// <returns></returns>
private async Task CheckActiveTradesAgainstStrategy()
{
// Check our active trades for a sell signal from the strategy
foreach (var trade in _activeTrades.Where(x => (x.OpenOrderId == null || x.SellType == SellType.Immediate) && x.IsOpen))
{
var signal = await GetStrategySignal(trade.Market);
// If the strategy is telling us to sell we need to do so.
if (signal != null && signal.TradeAdvice == TradeAdvice.Sell)
{
// If the trade is an immediate order, we leave it alone.
if ((trade.IsSelling && trade.SellType == SellType.Immediate))
{
return;
}
// Create a sell order for our strategy.
var ticker = await _api.GetTicker(trade.Market);
var orderId = await _api.Sell(trade.Market, trade.Quantity, ticker.Bid);
trade.CloseRate = ticker.Bid;
trade.OpenOrderId = orderId;
trade.SellOrderId = orderId;
trade.SellType = SellType.Strategy;
trade.IsSelling = true;
await _dataStore.SaveTradeAsync(trade);
}
}
}
/// <summary>
/// Checks our current running trades against the strategy.
/// If the strategy tells us to sell we need to do so.
/// </summary>
/// <returns></returns>
private async Task CheckActiveTradesAgainstStrategy()
{
// Check our active trades for a sell signal from the strategy
foreach (var trade in _activeTrades.Where(x => (x.OpenOrderId == null || x.SellType == SellType.Immediate) && x.IsOpen))
{
var signal = await GetStrategySignal(trade.Market);
// If the strategy is telling us to sell we need to do so.
if (signal != null && signal.TradeAdvice == TradeAdvice.Sell)
{
if ((trade.IsSelling && trade.SellType == SellType.Immediate))
{
// If an immediate order is placed it needs to be cancelled first.
await _api.CancelOrder(trade.OpenOrderId, trade.Market);
}
// Create a sell order for our strategy.
var ticker = await _api.GetTicker(trade.Market);
var orderId = await _api.Sell(trade.Market, trade.Quantity, ticker.Bid);
trade.CloseRate = ticker.Bid;
trade.OpenOrderId = orderId;
trade.SellOrderId = orderId;
trade.SellType = SellType.Strategy;
trade.IsSelling = true;
_orderBatch.Add(TableOperation.Replace(trade));
await SendNotification($"Sell order placed for {trade.Market} at {trade.CloseRate:0.00000000} (Strategy sell).");
}
}
}
/// <summary>
/// Checks our current running trades against the strategy.
/// If the strategy tells us to sell we need to do so.
/// </summary>
/// <returns></returns>
private async Task CheckActiveTradesAgainstStrategy()
{
// Check our active trades for a sell signal from the strategy
foreach (var trade in _activeTrades.Where(x => (x.OpenOrderId == null || x.SellType == SellType.Immediate) && x.IsOpen))
{
var signal = await GetStrategySignal(trade.Market);
// If the strategy is telling us to sell we need to do so.
if (signal != null && signal.TradeAdvice == TradeAdvice.Sell)
{
// Create a sell order for our strategy.
var ticker = await _api.GetTicker(trade.Market);
var orderId = Guid.NewGuid().ToString().Replace("-", "");
trade.CloseRate = ticker.Bid;
trade.OpenOrderId = orderId;
trade.SellOrderId = orderId;
trade.SellType = SellType.Strategy;
trade.IsSelling = true;
await _dataStore.SaveTradeAsync(trade);
}
}
}
/// <summary>
/// Checks if new trades can be started.
/// </summary>
/// <returns></returns>
public async Task LookForNewTrades()
{
var trades = await FindBuyOpportunities();
if (trades.Count > 0)
{
foreach (var trade in trades)
{
// Depending on what we have more of we create trades.
// The amount here is an indication and will probably not be precisely what you get.
var ticker = await _api.GetTicker(trade.MarketName);
var openRate = GetTargetBid(ticker, trade.SignalCandle);
var stop = openRate * (1 + _settings.StopLossPercentage);
if (trade.TradeAdvice == TradeAdvice.Buy)
{
await SendNotification($"ℹ️ {_strategy.Name} - #{trade.MarketName} at {openRate:0.00000000}\n" + _buyMessage);
}
else if (trade.TradeAdvice == TradeAdvice.Sell)
{
await SendNotification($"ℹ️ {_strategy.Name} - #{trade.MarketName} at {openRate:0.00000000}\n" + _sellMessage);
}
}
}
else
{
_logger.LogInformation("No trade opportunities found...");
}
}
public void GdaxIntegrationBuyTest()
{
Bot bot = _dbContext
.Bots
.Include("BaseCoin")
.Include("Coin")
.Single(x => x.BotId == 1);
ExchangeSettings exchangeSettings = _mapper.Map <ApiSetting, ExchangeSettings>(
_user.ApiSettings.Single(x => x.Exchange.ExchangeId == bot.Exchange.ExchangeId),
new ExchangeSettings());
exchangeSettings.Simulate = false;
_exchangeApi = ExchangeEngine.ExchangeFactory.GetExchangeApi(
(Enumerations.ExchangesEnum)bot.Exchange.ExchangeId, exchangeSettings);
Ticker ticker = _exchangeApi.GetTicker(bot.BaseCoin, bot.Coin);
bot.Amount = 10m; // 3 euros
OrderManager orderManager = new OrderManager(bot, new Trader(_logger), _dbContext, _logger, _mapper, _messagingApp);
orderManager.Buy(new Candle()
{
ClosePrice = ticker.Ask, Timestamp = DateTime.Now
});
}
public Ticker GetLatestTicker(Coin baseCoin, Coin coin)
{
return(_exchangeApi.Simulated ?
new Ticker {
Ask = _simulatedOrderResult.AveragePrice, Bid = _simulatedOrderResult.AveragePrice
}
: _exchangeApi.GetTicker(baseCoin, coin));
}
public void GetBTCTickerTest()
{
// Arrange
IExchangeApi exchangeApi = ExchangeFactory.GetExchangeApi(Enumerations.ExchangesEnum.Gdax, _exchangeSettings);
// Act
var response = exchangeApi.GetTicker(new Coin()
{
Code = "BTC"
}, new Coin()
{
Code = "EUR"
});
// Asert
Assert.IsNotNull(response);
}
public void GdaxIntegrationSellTest()
{
Bot bot = _dbContext
.Bots
.Include("BaseCoin")
.Include("Coin")
.Include("CurrentPosition")
.Single(x => x.BotId == 1);
if (bot == null || bot.CurrentPosition == null ||
bot.CurrentPosition.Status != Enumerations.PositionStatusEnum.Bought)
{
throw new Exception("No current open position");
}
ExchangeSettings exchangeSettings = _mapper.Map <ApiSetting, ExchangeSettings>(
_user.ApiSettings.Single(x => x.Exchange.ExchangeId == bot.Exchange.ExchangeId),
new ExchangeSettings());
exchangeSettings.Simulate = false;
_exchangeApi = ExchangeEngine.ExchangeFactory.GetExchangeApi(
(Enumerations.ExchangesEnum)bot.Exchange.ExchangeId, exchangeSettings);
Ticker ticker = _exchangeApi.GetTicker(bot.BaseCoin, bot.Coin);
bot.Amount = 10M; // €2
OrderManager orderManager = new OrderManager(bot, new Trader(_logger), _dbContext, _logger, _mapper, _messagingApp);
orderManager.Sell(new Candle()
{
ClosePrice = ticker.Ask, Timestamp = DateTime.Now
});
}
/// <summary>
/// Checks the implemented trading indicator(s),
/// if one pair triggers the buy signal a new trade record gets created.
/// </summary>
/// <param name="trades"></param>
/// <param name="amountOfBtcToInvestPerTrader"></param>
/// <returns></returns>
private async Task <Trade> FindTrade(List <Trade> trades, double amountOfBtcToInvestPerTrader)
{
// Get our Bitcoin balance from the exchange
var currentBtcBalance = await _api.GetBalance("BTC");
// Do we even have enough funds to invest?
if (currentBtcBalance < Constants.AmountOfBtcToInvestPerTrader)
{
throw new Exception("Insufficient BTC funds to perform a trade.");
}
// Retrieve our current markets
var markets = await _api.GetMarketSummaries();
// Check if there are markets matching our volume.
markets = markets.Where(x => (x.BaseVolume > Constants.MinimumAmountOfVolume || Constants.AlwaysTradeList.Contains(x.MarketName)) && x.MarketName.StartsWith("BTC-")).ToList();
// Remove existing trades from the list to check.
foreach (var trade in trades)
{
markets.RemoveAll(x => x.MarketName == trade.Market);
}
// Remove items that are on our blacklist.
foreach (var market in Constants.MarketBlackList)
{
markets.RemoveAll(x => x.MarketName == market);
}
// Check the buy signal!
string pair = null;
// Prioritize markets with high volume.
foreach (var market in markets.Distinct().OrderByDescending(x => x.BaseVolume).ToList())
{
if (await GetBuySignal(market.MarketName))
{
// A match was made, buy that please!
pair = market.MarketName;
break;
}
}
// No pairs found. Return.
if (pair == null)
{
return(null);
}
var openRate = GetTargetBid(await _api.GetTicker(pair));
var amount = amountOfBtcToInvestPerTrader / openRate;
var amountYouGet = (amountOfBtcToInvestPerTrader * (1 - Constants.TransactionFeePercentage)) / openRate;
var orderId = await _api.Buy(pair, openRate, amount);
return(new Trade()
{
Market = pair,
StakeAmount = Constants.AmountOfBtcToInvestPerTrader,
OpenRate = openRate,
OpenDate = DateTime.UtcNow,
Quantity = amountYouGet,
OpenOrderId = orderId,
BuyOrderId = orderId,
IsOpen = true,
StrategyUsed = _strategy.Name,
PartitionKey = "TRADE",
SellType = SellType.None,
RowKey = $"MNT{(DateTime.MaxValue.Ticks - DateTime.UtcNow.Ticks):d19}"
});
}
