protected virtual void PlaceSellOrder(TradingData trade, bool forReal)
{
if (trade.CoinQuantityToTrade == 0)
{
throw new Exception("CoinQuantityToTrade is not set!");
}
decimal fees = _client.GetTradeFee(trade.CoinPair);
decimal totalReceived = trade.CoinQuantityToTrade * trade.Price / (1 + fees);
var sellOrder = forReal ? _client.PlaceSellOrder(trade) : _client.PlaceTestSellOrder(trade);
if (sellOrder)
{
trade.SellPriceAfterFees = totalReceived / trade.CoinQuantityToTrade;
trade.LastAction = OrderSide.Sell;
Bot.WriteLog(trade.ToStringSold());
if (trade.BuyPriceAfterFees > 0)
{
if (forReal)
{
_settings.TotalProfit += trade.Profit;
}
else
{
_settings.TotalProfitSimulation += trade.Profit;
}
}
OnOrderSucceeded(trade);
Sleep();
}
}
public override void Trade(List <TradingData> tradesList)
{
// Check USDT and BTC balances
decimal coins = _client.GetBalance(_settings.CoinPair.Pair1);
decimal fiatValue = _client.GetBalance(_settings.CoinPair.Pair2);
// Check if user has more USDT or more BTC
decimal coinsValue = coins * _client.GetPrice(_settings.CoinPair);
// cleanup
tradesList.RemoveAll(trade => trade.BuyOrderID > -1 && trade.SellOrderID > -1);
// If no buy or sell orders for the required coin pair, then place an order
TradingData tdSearch = tradesList.Find(x => x.CoinPair.Pair1 == _settings.CoinPair.Pair1);
if (tdSearch == null)
{
// buy or sell?
if (fiatValue > _settings.InvestmentMin)
{
// buy
PlaceBuyOrder(GetNewTradingData(), _settings.TradingDataList, _settings.ProductionMode);
}
else
{
// sell
TradingData trade0 = GetNewTradingData();
trade0.CoinQuantity = Math.Round(coins / _settings.HydraFactor, 5);
tradesList.Add(trade0); // Add because this is the seed
PlaceSellOrder(trade0, forReal: _settings.ProductionMode);
}
}
// monitor market price for price changes
Bot.WriteConsole();
foreach (TradingData trade in tradesList)
{
if (trade.UpdateMarketPrice(_client.GetPrice(trade.CoinPair)))
{
trade.SetPriceChangePercentage(trade.Price);
Bot.WriteConsole(trade.ToStringPriceCheck());
OnTradeListItemHandled(trade);
// sell if positive price change
if (trade.PriceChangePercentage > Math.Abs(_settings.PriceChangePercentageUp))
{
PlaceSellOrder(trade, forReal: _settings.ProductionMode);
}
Sleep();
}
}
TradingData lastTrade = tradesList.Last <TradingData>();
if (lastTrade.PriceChangePercentage < Math.Abs(_settings.PriceChangePercentageDown) * -1)
{
// buy more if negative price change
PlaceBuyOrder(GetNewTradingData(), _settings.TradingDataList, _settings.ProductionMode);
}
}
private void Strategy_OrderSuccess(TradingData trade)
{
this.InvokeSafe(() =>
{
niTray.ShowBalloonTip(5000, Application.ProductName, trade.ToString(), ToolTipIcon.Info);
});
}
protected override void PlaceBuyOrder(TradingData trade, List <TradingData> tradesList, bool forReal)
{
decimal fiatValue = _client.GetBalance(trade.CoinPair.Pair2);
decimal capitalCost = fiatValue / _settings.HydraFactor;
if (trade.UpdateMarketPrice(_client.GetPrice(trade.CoinPair)))
{
Bot.WriteConsole();
decimal fees = _client.GetTradeFee(trade.CoinPair);
decimal myInvestment = capitalCost / (1 + fees);
if (trade.CoinQuantity == 0)
{
trade.CoinQuantity = myInvestment / trade.Price;
}
var buyOrder = forReal ? _client.PlaceBuyOrder(trade) : _client.PlaceTestBuyOrder(trade);
if (buyOrder)
{
trade.BuyPriceAfterFees = capitalCost / trade.CoinQuantity;
trade.ID = tradesList.Count;
trade.LastAction = OrderSide.Buy;
tradesList.Add(trade);
Bot.WriteLog(trade.ToStringBought());
OnOrderSucceeded(trade);
}
}
}
private void PlacePartialSellOrder(TradingData trade, bool forReal)
{
if (trade.CoinQuantity > trade.CoinOriginalQuantity * _settings.SellMaxQuantityPerc / 100)
{
trade.CoinQuantityToTrade = trade.CoinQuantity * _settings.SellQuantityPerc / 100;
base.PlaceSellOrder(trade, forReal);
}
}
protected void PlaceCompleteSellOrder(TradingData trade, bool forReal)
{
if (trade.UpdateMarketPrice(Math.Round(_client.GetPrice(trade.CoinPair), 2)))
{
trade.CoinQuantityToTrade = trade.CoinQuantity;
base.PlaceSellOrder(trade, forReal);
}
}
public void TradingData_is_singleton()
{
TradingData td = TradingData.Instance;
TradingData td2 = TradingData.Instance;
Assert.IsNotNull(td);
Assert.IsNotNull(td2);
Assert.AreSame(td, td2);
}
protected void OnOrderSucceeded(TradingData data)
{
OrderSucceeded?.Invoke(data);
#if DEBUG
if (_settings.ProductionMode)
{
Bot.SaveSettings(_settings);
}
#endif
#if RELEASE
Bot.SaveSettings(_settings);
#endif
}
protected override void PlaceSellOrder(TradingData trade, bool forReal)
{
if (trade.UpdateMarketPrice(Math.Round(_client.GetPrice(trade.CoinPair), 2)))
{
if (trade.Price > trade.BuyPriceAfterFees)
{
trade.CoinQuantityToTrade = trade.CoinQuantity; // trading the full amount
decimal dmReceived = trade.CoinQuantityToTrade * trade.Price;
if (dmReceived > _settings.InvestmentMin)
{
base.PlaceSellOrder(trade, forReal);
}
}
}
}
private void Strategy_Handled(TradingData trade)
{
this.InvokeSafe(() =>
{
lvStatus.Items.Add(trade.ToListViewItem()); // this updates UI
lvStatistics.Items.Clear();
// Futures
if (trade.PriceLongBelow > 0) // this does not update UI
{
string orders = trade.ProfitTarget > 0 ? " for new orders" : "";
AddStatistic($"Long Below{orders}", trade.PriceLongBelow.ToString());
AddStatistic($"Short Above{orders}", trade.PriceShortAbove.ToString());
}
if (trade.ProfitTarget > 0)
{
AddStatistic("Target Profit", trade.ProfitTarget.ToString());
}
});
}
private static void Trade3()
{
// Settings
BTCMarketsHelper.ProfitMargin = 0;
// Get number of Open Orders
OpenOrdersHistory = BTCMarketsHelper.OrderOpen(CURRENCY, INSTRUMENT, 10, "1");
if (OpenOrdersHistory.success && OpenOrdersHistory.orders != null)
{
if (OpenOrdersHistory.orders.Length > 1)
{
Console.WriteLine("Open orders are still active...");
}
else
{
// get ETH/BTC market data i.e. instrument/currency
Console.WriteLine($"Previous Ask Price: {lastETH_BTC}");
MarketTickData marketData = BTCMarketsHelper.GetMarketTick($"{INSTRUMENT}/{CURRENCY}");
Console.WriteLine($"Current Ask Price: {marketData.bestAsk}");
lastETH_BTC = marketData.bestAsk;
// get trading data
TradingData tradingData = TradingHelper.GetTradingData(marketData);
if (lastETH_BTC > 0) // ensure first round is skipped when there is no history
{
if (marketData.bestAsk > lastETH_BTC)
{
Console.WriteLine($"Previous Volume (BTC): {lastBTC_Volume}");
if (tradingData.BuyVolume > lastBTC_Volume)
{
Console.WriteLine("ETH has gone stronger. Sell ETH.");
}
}
else if (marketData.bestAsk < lastETH_BTC)
{
Console.WriteLine("BTC has gone stronger. Buy ETH.");
Console.WriteLine($"Previous Buy Volume (ETH): {lastETH_Volume}");
Console.WriteLine($"Current Buy volume ({marketData.instrument}): {tradingData.BuyVolume}");
}
}
Console.WriteLine($"Buy price ({marketData.currency}): {tradingData.BuyPrice}");
Console.WriteLine($"Sell volume ({marketData.instrument}): {tradingData.SellVolume}");
Console.WriteLine($"Sell price ({marketData.currency}): {tradingData.SellPrice}");
Console.WriteLine($"Spend total ({marketData.currency}): {tradingData.SpendTotal}");
/*
* // create orders
* CreateOrderData buyOrder = BTCMarketsHelper.CreateNewOrder(marketData.currency, marketData.instrument,
* (long)(tradingData.BuyPrice * ApplicationConstants.NUMERIC_MULTIPLIER),
* (int)(tradingData.BuyVolume * ApplicationConstants.NUMERIC_MULTIPLIER),
* "Bid", "Limit");
*
* if (buyOrder.success)
* {
* CreateOrderData sellOrder = BTCMarketsHelper.CreateNewOrder(marketData.currency, marketData.instrument,
* (long)(tradingData.SellPrice * ApplicationConstants.NUMERIC_MULTIPLIER),
* (int)(tradingData.SellVolume * ApplicationConstants.NUMERIC_MULTIPLIER),
* "Ask", "Limit");
*
* if (sellOrder.success)
* {
* // append csv line
* BotLogger.WriteLine($",{tradingData.BuyVolume.ToDecimalString(8)}, {marketData.instrument}, Balance (Unit 2), " +
* $"{tradingData.BuyPrice.ToDecimalString(8)}, {marketData.currency}, {tradingData.SpendTotal.ToDecimalString(8)}, {BTCMarketsHelper.ProfitMargin}%, " +
* $"{tradingData.SellVolume.ToDecimalString(8)}, {tradingData.SellPrice.ToDecimalString(8)}");
* }
* else
* {
* Console.WriteLine(sellOrder.errorMessage);
* }
* }
* else
* {
* Console.WriteLine(buyOrder.errorMessage);
* }
*/
}
}
else
{
Console.WriteLine(OpenOrdersHistory.errorMessage);
}
Console.WriteLine(CONSOLE_WAITING);
Console.WriteLine();
}
private static void Trade1()
{
// Settings
BTCMarketsHelper.ProfitMargin = 2;
// Get number of Open Orders
OpenOrdersHistory = BTCMarketsHelper.OrderOpen(CURRENCY, INSTRUMENT, 10, "1");
if (OpenOrdersHistory.success && OpenOrdersHistory.orders != null)
{
if (OpenOrdersHistory.orders.Length > 1)
{
Console.WriteLine("Open orders are still active...");
}
else
{
// get ETH/BTC market data i.e. instrument/currency
MarketTickData marketData = BTCMarketsHelper.GetMarketTick($"{INSTRUMENT}/{CURRENCY}");
// get trading data
TradingData tradingData = TradingHelper.GetTradingData(marketData, splitProfitMargin: true);
Console.WriteLine($"Buy volume ({marketData.instrument}): {tradingData.BuyVolume}");
Console.WriteLine($"Buy price ({marketData.currency}): {tradingData.BuyPrice}");
Console.WriteLine($"Sell volume ({marketData.instrument}): {tradingData.SellVolume}");
Console.WriteLine($"Sell price ({marketData.currency}): {tradingData.SellPrice}");
Console.WriteLine($"Spend total ({marketData.currency}): {tradingData.SpendTotal}");
// create orders
CreateOrderData buyOrder = BTCMarketsHelper.CreateNewOrder(marketData.currency, marketData.instrument,
(long)(tradingData.BuyPrice * ApplicationConstants.NUMERIC_MULTIPLIER),
(long)(tradingData.BuyVolume * ApplicationConstants.NUMERIC_MULTIPLIER),
"Bid", "Limit");
if (buyOrder.success)
{
System.Threading.Thread.Sleep(rnd.Next(1, 10) * 1000);
CreateOrderData sellOrder = BTCMarketsHelper.CreateNewOrder(marketData.currency, marketData.instrument,
(long)(tradingData.SellPrice * ApplicationConstants.NUMERIC_MULTIPLIER),
(long)(tradingData.SellVolume * ApplicationConstants.NUMERIC_MULTIPLIER),
"Ask", "Limit");
if (sellOrder.success)
{
// append csv line
BotLogger.WriteLine($",{tradingData.BuyVolume}, {marketData.instrument}, Balance (Unit 2), " +
$"{tradingData.BuyPrice}, {marketData.currency}, {tradingData.SpendTotal}, {BTCMarketsHelper.ProfitMargin}%, " +
$"{tradingData.SellVolume}, {tradingData.SellPrice}");
}
else
{
Console.WriteLine(sellOrder.errorMessage);
}
}
else
{
Console.WriteLine(buyOrder.errorMessage);
}
}
}
else
{
Console.WriteLine(OpenOrdersHistory.errorMessage);
}
Console.WriteLine(CONSOLE_WAITING);
Console.WriteLine();
}
public TradingDataViewModel(TradingData data) : this()
{
Assign(data);
}
public ChartDataset GetChartData(ChartSettings settings)
{
var chartDataset = new ChartDataset();
chartDataset.Candles = _candleLoadingService.LoadCandles(
settings.CurrencyPairId,
settings.Period,
settings.CandleRangeSize,
settings.CurrentMoment).ToList();
foreach (var indicatorSettings in settings.Indicators)
{
var indicatorDataset = new IndicatorDataset();
indicatorDataset.Settings = indicatorSettings;
var candles = indicatorSettings.CandlePeriod != settings.Period ?
_candleLoadingService.LoadCandles(
settings.CurrencyPairId,
indicatorSettings.CandlePeriod,
settings.CandleRangeSize,
settings.CurrentMoment).ToList() :
chartDataset.Candles;
switch (indicatorSettings.Type)
{
case IndicatorType.HighestMaxPrice:
indicatorDataset.Values = _indicatorComputingService.ComputeHighestMaxPrices(
candles,
((CommonIndicatorSettings)indicatorSettings).Period);
break;
case IndicatorType.EMA:
indicatorDataset.Values = _indicatorComputingService.ComputeEMA(
candles,
((CommonIndicatorSettings)indicatorSettings).Period);
break;
case IndicatorType.MACD:
indicatorDataset.Values = _indicatorComputingService.ComputeMACD(
candles,
((MACDSettings)indicatorSettings).EMAPeriod1,
((MACDSettings)indicatorSettings).EMAPeriod2,
((MACDSettings)indicatorSettings).SignalPeriod);
break;
case IndicatorType.Stochastic:
indicatorDataset.Values = _indicatorComputingService.ComputeStochastic(
candles,
((StochasticSettings)indicatorSettings).Period,
((StochasticSettings)indicatorSettings).SMAPeriodK,
((StochasticSettings)indicatorSettings).SMAPeriodD);
break;
case IndicatorType.RelativeStrengthIndex:
indicatorDataset.Values = _indicatorComputingService.ComputeRelativeStrengthIndex(
candles,
((CommonIndicatorSettings)indicatorSettings).Period);
break;
case IndicatorType.AccumulationDistribution:
indicatorDataset.Values = _indicatorComputingService.ComputeAccumulationDistribution(
candles);
break;
case IndicatorType.WilliamsR:
indicatorDataset.Values = _indicatorComputingService.ComputeWilliamsR(
candles,
((CommonIndicatorSettings)indicatorSettings).Period);
break;
case IndicatorType.ParabolicSAR:
indicatorDataset.Values = _indicatorComputingService.ComputeParabolicSAR(candles);
break;
default:
throw new AnalysisException("Undefined indicator type");
}
chartDataset.IndicatorData.Add(indicatorDataset);
}
var defaultTradingSettings = _configurationService.GetTradingSettings();
var tradingSettings = _configurationService.GetTradingSettings();
tradingSettings.Period = settings.Period;
tradingSettings.Moment = settings.CurrentMoment;
_configurationService.UpdateTradingSettings(tradingSettings);
foreach (var candle in chartDataset.Candles)
{
tradingSettings.Moment = candle.Moment;
_configurationService.UpdateTradingSettings(tradingSettings);
//var newPositionInfo = await _marketNewPositionAnalysisService.ProcessMarketPosition(settings.CurrencyPairId);
var tradingData = new TradingData
{
Moment = candle.Moment
};
//switch (newPositionInfo.PositionType)
//{
// case NewMarketPositionType.Buy:
// tradingData.BuyPrice = candle.ClosePrice;
// break;
//}
chartDataset.TradingData.Add(tradingData);
}
_configurationService.UpdateTradingSettings(defaultTradingSettings);
return(chartDataset);
}
protected void OnTradeListItemHandled(TradingData data)
{
TradeListItemHandled?.Invoke(data);
}
public CompanyTradingDataViewModel(TradingData data, string companyName, int rise, double totalRise) : base(data)
{
CompanyName = companyName;
TotalRise = totalRise;
Rise = rise;
}
public TradingDataViewModel()
{
tradingData = new TradingData();
}
public override void Trade(List <TradingData> tradesList)
{
if (tradesList.Count > 0)
{
// Check for stop losses
foreach (TradingData trade in tradesList)
{
OnTradeListItemHandled(trade);
if (trade.UpdateMarketPrice(_client.GetPrice(trade.CoinPair)))
{
// Update PriceChangePercentage
trade.SetPriceChangePercentage(trade.Price);
decimal stopLossPrice = trade.BuyPriceAfterFees * (1 - _settings.StopLossPerc / 100);
if (trade.Price < stopLossPrice)
{
PlaceCompleteSellOrder(trade, forReal: _settings.ProductionMode);
}
}
}
// cleanup
tradesList.RemoveAll(td => td.BuyOrderID > -1 && td.SellOrderID > -1 && td.CoinQuantity == 0);
}
// Check for new email every second
EmailHelper agent = new EmailHelper(_settings);
// Check for new email
if (!agent.NewMail)
{
Bot.WriteConsole($"{DateTime.Now} No new mail!");
return;
}
// buy or sell signal
if (!string.IsNullOrEmpty(agent.Subject))
{
if (!agent.Subject.Contains(_settings.SecretWord))
{
return; // SPAM!
}
// Match coin pair
CoinPair coinPair = new CoinPairHelper(_settings).GetCoinPair(agent.Subject);
if (coinPair == null)
{
Console.WriteLine("CoinPair not supported!");
return;
}
if (agent.Subject.Contains("Buy"))
{
_signal = OrderSide.Buy;
}
else if (agent.Subject.Contains("Sell"))
{
_signal = OrderSide.Sell;
}
// If no buy or sell orders for the required coin pair, then place an order
TradingData tdSearch = tradesList.Find(x => x.CoinPair.Pair1 == coinPair.Pair1);
if (tdSearch == null)
{
TradingData trade = new TradingData(coinPair);
switch (_signal)
{
case OrderSide.Buy:
PlaceBuyOrder(trade, tradesList, forReal: _settings.ProductionMode);
break;
}
}
else // existing trades detected
{
foreach (TradingData trade in tradesList)
{
if (_signal == OrderSide.Sell)
{
if (_settings.SellAllOnSellSignal)
{
PlaceCompleteSellOrder(trade, _settings.ProductionMode);
}
else
{
PlacePartialSellOrder(trade, forReal: _settings.ProductionMode);
}
}
}
}
}
}
public void Assign(TradingData data)
{
tradingData.Assign(data);
OnPropertyChanged("Price");
OnPropertyChanged("Volume");
}
public override void Trade()
{
using (var tempClient = new BinanceFuturesClient())
{
var openOrders = tempClient.GetOpenOrders().Data;
TradingData trade = new TradingData(new CoinPair("BTC", "USDT", 3));
var pos = tempClient.GetOpenPositions().Data.Single(s => s.Symbol == trade.CoinPair.ToString());
trade.UpdateMarketPrice(pos.MarkPrice);
Console.WriteLine($"{DateTime.Now} Entry Price: {pos.EntryPrice} Unrealised PnL: {pos.UnrealizedPnL}");
var dataLast24hr = tempClient.Get24HPrice(trade.CoinPair.ToString()).Data;
decimal priceDiff = dataLast24hr.WeightedAveragePrice - dataLast24hr.LowPrice;
if (_settings.IsAutoAdjustShortAboveAndLongBelow)
{
trade.PriceLongBelow = Math.Round(dataLast24hr.WeightedAveragePrice - priceDiff * 0.618m, 2);
decimal entryPrice = pos.EntryPrice == 0 ? dataLast24hr.WeightedAveragePrice : pos.EntryPrice;
trade.PriceShortAbove = Math.Round(priceDiff * 0.618m + entryPrice, 2);
}
else
{
trade.PriceLongBelow = _settings.LongBelow;
trade.PriceShortAbove = _settings.ShortAbove;
}
if (_settings.IsAutoAdjustTargetProfit)
{
trade.ProfitTarget = Math.Round(Math.Abs(pos.Quantity) / pos.Leverage * pos.EntryPrice * 0.618m, 2);
}
else
{
trade.ProfitTarget = _settings.FuturesProfitTarget;
}
// If zero positions
if (pos.EntryPrice == 0 && openOrders.Count() == 0)
{
decimal investment = _client.GetBalance(trade.CoinPair.Pair2) / _settings.FuturesSafetyFactor; // 11 is to have the liquidation very low or high
trade.CoinQuantity = investment / trade.Price * pos.Leverage; // 20x leverage
// Short above or Long below
if (trade.Price < trade.PriceLongBelow)
{
_client.PlaceBuyOrder(trade);
}
else if (trade.Price > trade.PriceShortAbove)
{
_client.PlaceSellOrder(trade);
}
}
// When there is an existing position
else if (pos.EntryPrice > 0)
{
if (pos.LiquidationPrice < pos.EntryPrice) // Long position
{
trade.LastAction = Binance.Net.Enums.OrderSide.Buy;
}
else
{
trade.LastAction = Binance.Net.Enums.OrderSide.Sell;
}
if (pos.UnrealizedPnL > 0)
{
trade.CoinQuantity = pos.Quantity;
bool success;
bool targetProfitMet = trade.ProfitTarget > 0 && pos.UnrealizedPnL > trade.ProfitTarget;
if (trade.LastAction == Binance.Net.Enums.OrderSide.Buy && (targetProfitMet || pos.MarkPrice > trade.PriceShortAbove)) // i.e. Long position
{
success = _client.PlaceSellOrder(trade, closePosition: true);
}
else if (trade.LastAction == Binance.Net.Enums.OrderSide.Sell && (targetProfitMet || pos.MarkPrice < trade.PriceLongBelow))
{
success = _client.PlaceBuyOrder(trade, closePosition: true);
}
else
{
success = false;
}
if (success)
{
_settings.TotalProfit += pos.UnrealizedPnL;
}
}
}
// Below is for statistics and to keep UI up-to-date
trade.SetQuantity(pos.Quantity);
trade.SellPriceAfterFees = trade.BuyPriceAfterFees = pos.EntryPrice;
trade.SetPriceChangePercentage(pos.MarkPrice, isFutures: true);
OnTradeListItemHandled(trade);
}
}
