public void CalculateProfitsWithInvalidInputs(decimal[] stockPrices, Type exceptionType)
{
var profitCalculator = new ProfitCalculator();
var exception = Record.Exception(() => profitCalculator.GetMaximumProfit(stockPrices));
exception.Should().BeOfType(exceptionType);
}
public void CalculateProfits(decimal[] stockPrices, decimal optimalProfit)
{
var profitCalculator = new ProfitCalculator();
var profit = profitCalculator.GetMaximumProfit(stockPrices);
profit.Should().Be(optimalProfit);
}
public void TestNoProfitSequenceReturnsFalse()
{
ProfitCalculator calculator = new ProfitCalculator();
bool realResult = calculator.Process(new int[] { 10, 9, 8, 7 });
Assert.False(realResult);
}
public void TestSellProfit()
{
_trades = new List <Trade>
{
CreateTrade("BTC", "XPM", 0.0025M, 0.00003980M, 0.00552158M, 138.73325317M, TradeSide.Buy,
new DateTime(2017, 09, 29, 19, 22, 56)),
CreateTrade("BTC", "XPM", 0.0025M, 0.00003911M, 0.01083815M, 277.11967321M, TradeSide.Buy,
new DateTime(2017, 09, 29, 20, 13, 5)),
CreateTrade("BTC", "XPM", 0.0025M, 0.00004084M, 0.00568006M, 139.08095555M, TradeSide.Buy,
new DateTime(2017, 09, 29, 19, 22, 56)),
};
ProfitCalculator.GetProfitForTrade(_trades, 0.02249510M, 553.54654724M, out decimal? totalCost, out decimal? profitPercent, out DateTime boughtDate);
decimal?btcProfit = 0.02249510M - totalCost.Value;
var dateTime = new DateTime(2017, 09, 29, 20, 13, 56);
Assert.AreEqual(dateTime.Year, boughtDate.Year);
Assert.AreEqual(dateTime.Month, boughtDate.Month);
Assert.AreEqual(dateTime.Day, boughtDate.Day);
Assert.AreEqual(dateTime.Second, boughtDate.Second);
Assert.AreEqual(0.0219831374759224m, totalCost);
Assert.AreEqual(0.0005119625240776m, btcProfit);
Assert.AreEqual(2.329, profitPercent);
}
static void Main(string[] args)
{
var data = new List <int>();
do
{
Console.WriteLine("Please, type values, separated by comma...");
var input = Console.ReadLine();
data = Helper.NormalizeInput(input);
} while (data.Count == 0);
int[] dataAsArray = data.ToArray();
var profitCalculator = new ProfitCalculator();
if (!profitCalculator.Process(dataAsArray))
{
Console.WriteLine("No profit possible or unexpected error occured during the profit calculation");
Environment.Exit(-1);
}
Console.WriteLine("Buy at {0} and sell at {1} for a maximum profit of {2}.",
profitCalculator.GetBuyPrice(),
profitCalculator.GetSellPrice(),
profitCalculator.GetMaxProfit()
);
}
private static void RunSPRGood()
{
Product lProduct = new Product
{
Price = 150,
Units = 15,
Name = "Watermelon"
};
DiscountProvider discountProvider = new DiscountProvider();
ProfitCalculator profitCalculator = new ProfitCalculator(0.2, 90);
ProductDisplayer.DisplayProduct(lProduct);
lProduct.Price -= discountProvider.ApplyDiscount(profitCalculator.CalculateProfit(lProduct.Price));
lProduct.SellProduct(1);
ProductDisplayer.DisplayProduct(lProduct);
lProduct.Price -= discountProvider.ApplyDiscount(profitCalculator.CalculateProfit(lProduct.Price));
lProduct.SellProduct(2);
profitCalculator.Tax = 0.1;
ProductDisplayer.DisplayProduct(lProduct);
lProduct.Price -= discountProvider.ApplyDiscount(profitCalculator.CalculateProfit(lProduct.Price));
lProduct.SellProduct(3);
ProductDisplayer.DisplayProduct(lProduct);
lProduct.Price -= discountProvider.ApplyDiscount(profitCalculator.CalculateProfit(lProduct.Price));
lProduct.SellProduct(2);
}
private async Task BagManagement(decimal currentPrice, Trade lastTradeForPair, WalletBalance walletBalance)
{
var percentageDrop = ProfitCalculator.PriceDifference(currentPrice, lastTradeForPair.Limit);
if (percentageDrop < -_bagConfig.PercentageDrop)
{
await SendBagNotification(walletBalance, lastTradeForPair, currentPrice, percentageDrop);
}
}
public void CanCalculateProfit()
{
double[] raw = new double[] { 1.0, 2.2, 3.1, 6, 7, 2.3, 7.2, 8.2 };
var profit = ProfitCalculator.CalculateProfit(raw.Length, raw);
Assert.IsTrue(profit.AlmostEqual(-87.8));
profit = ProfitCalculator.CalculateProfit(2, raw);
Assert.IsTrue(profit.AlmostEqual(-54.545454));
}
public async Task <BalanceInformation> GetBalance()
{
List <WalletBalance> poloniexToWalletBalances;
try
{
var balances = await _poloniexClient.Wallet.GetBalancesAsync();
poloniexToWalletBalances = TradeConverter.PoloniexToWalletBalances(balances);
}
catch (Exception e)
{
_log.LogError("Error in getting balances from poloniex: " + e.Message);
throw;
}
var totalBtcBalance = 0m;
foreach (var balance in poloniexToWalletBalances)
{
if (balance.BtcAmount == 0)
{
continue;
}
var price = await GetPrice("BTC", balance.Currency);
var boughtPrice = 0m;
var lastTradeForPair1 = _databaseService.GetLastTradeForPair(balance.Currency, Constants.Poloniex, TradeSide.Buy);
if (lastTradeForPair1 != null)
{
boughtPrice = lastTradeForPair1.Limit;
}
try
{
balance.PercentageChange = ProfitCalculator.PriceDifference(price, boughtPrice);
}
catch
{
// There maybe a divide by 0 issue if we couldn't find the last trade. Its fine. Just print zero
balance.PercentageChange = 0;
}
balance.Price = price;
totalBtcBalance = totalBtcBalance + balance.BtcAmount;
}
var lastBalance = _databaseService.GetBalance24HoursAgo(Constants.Poloniex);
var dollarAmount = await _priceService.GetDollarAmount(totalBtcBalance);
var currentBalance = await _databaseService.AddBalance(totalBtcBalance, dollarAmount, Constants.Poloniex);
await _databaseService.AddWalletBalances(poloniexToWalletBalances);
return(new BalanceInformation(currentBalance, lastBalance, Constants.Poloniex, poloniexToWalletBalances));
}
private async Task BagManagement(decimal currentPrice, decimal averagePrice, WalletBalance walletBalance)
{
var percentageDrop = ProfitCalculator.PriceDifference(currentPrice, averagePrice);
if (_config.BagNotification != null && percentageDrop < -_config.BagNotification.Value)
{
await SendBagNotification(walletBalance, averagePrice, currentPrice, percentageDrop);
}
}
public void TestPnL()
{
var profitAndLoss = ProfitCalculator.GetProfitAndLossForPair(_trades, "BTC", "LTC");
Assert.AreEqual(150, profitAndLoss.QuantityBought);
Assert.AreEqual(100, profitAndLoss.QuantitySold);
Assert.AreEqual(0.01M, profitAndLoss.Profit);
Assert.AreEqual(0.0001333333333333333333333333M, profitAndLoss.AverageBuyPrice);
Assert.AreEqual(0.0001M, profitAndLoss.AverageSellPrice);
Assert.AreEqual(0.002M, profitAndLoss.CommissionPaid);
}
public void TestPnL()
{
var profitAndLoss = ProfitCalculator.GetProfitAndLossForPair(_trades, new Currency { Base = "BTC", Terms = "LTC" });
Assert.AreEqual(150, profitAndLoss.QuantityBought);
Assert.AreEqual(100, profitAndLoss.QuantitySold);
Assert.AreEqual(-0.016666666666666666666666665m, profitAndLoss.Profit);
Assert.AreEqual(0.0001333333333333333333333333M, profitAndLoss.AverageBuyPrice);
Assert.AreEqual(0.0001M, profitAndLoss.AverageSellPrice);
Assert.AreEqual(0.002M, profitAndLoss.CommissionPaid);
}
public async Task <decimal> GetBuyAveragePrice(string ccy1, string ccy2, string exchange, decimal quantity)
{
var contextTrades = _context.Trades;
var onlyBuys = await contextTrades
.Where(x => x.Base == ccy1 && x.Terms == ccy2 && x.Exchange == exchange && x.Side == TradeSide.Buy)
.OrderByDescending(x => x.TimeStamp)
.ToListAsync();
var price = ProfitCalculator.GetAveragePrice(onlyBuys, quantity);
return(price);
}
public void TestPerTradeSellPnL()
{
_trades = new List <Trade>
{
CreateTrade("BTC", "LTC", 0.000M, 500m, 7500m, 15, TradeSide.Buy, DateTime.Now),
CreateTrade("BTC", "LTC", 0.000M, 1000m, 10000m, 10, TradeSide.Buy, DateTime.Now),
CreateTrade("BTC", "LTC", 0.000M, 1000m, 15000m, 19, TradeSide.Buy, DateTime.Now),
};
ProfitCalculator.GetProfitForTrade(_trades, 19800m, 18m, out decimal? totalCost, out decimal? profitAndLoss, out DateTime boughtdate);
Assert.AreEqual(88.571, profitAndLoss);
}
public void TestPerTradeSellPnL()
{
_trades = new List<Trade>
{
CreateTrade("BTC", "LTC", 0.000M, 500m, 7500m, 15, TradeSide.Buy, DateTime.Now),
CreateTrade("BTC", "LTC", 0.000M, 1000m, 10000m, 10, TradeSide.Buy, DateTime.Now - TimeSpan.FromDays(-1)),
CreateTrade("BTC", "LTC", 0.000M, 1000m, 15000m, 19, TradeSide.Buy, DateTime.Now - TimeSpan.FromDays(-2)),
};
var averagePrice = ProfitCalculator.GetAveragePrice(_trades, 19);
Assert.AreEqual(605.26, Math.Round(averagePrice, 2));
}
public async Task <ProfitAndLoss> GetPnLInfo(string ccy1, string ccy2)
{
var tradesForPair = _databaseService.GetTradesForPair(ccy1, ccy2);
var profitAndLoss = ProfitCalculator.GetProfitAndLossForPair(tradesForPair, ccy1, ccy2);
var dollarAmount = await _priceService.GetDollarAmount(profitAndLoss.Profit);
profitAndLoss.DollarProfit = dollarAmount;
_databaseService.SaveProfitAndLoss(profitAndLoss);
return(profitAndLoss);
}
public Indicator AnalyzeData(DataState state)
{
double[] closePrices = _analyseRepo.LoadClosePriceBySymbol(state.Symbol, false).ToArray();
Profit value = new Profit();
value.Symbol = state.Symbol;
value.Date = state.Last.Value;
value.R20Day = ProfitCalculator.CalculateProfit(20, closePrices);
value.R50Day = ProfitCalculator.CalculateProfit(50, closePrices);
value.R100Day = ProfitCalculator.CalculateProfit(100, closePrices);
value.R150Day = ProfitCalculator.CalculateProfit(150, closePrices);
value.R200Day = ProfitCalculator.CalculateProfit(200, closePrices);
return(value.ToIndicator());
}
public void TestResultFitsTaskConditions(
int[] source,
int buyPrice,
int sellPrice,
int maxProfit
)
{
ProfitCalculator calculator = new ProfitCalculator();
bool result = calculator.Process(source);
Assert.Equal(calculator.GetBuyPrice(), buyPrice);
Assert.Equal(calculator.GetSellPrice(), sellPrice);
Assert.Equal(calculator.GetMaxProfit(), maxProfit);
Assert.True(result);
}
public async Task <ProfitAndLoss> GetPnLInfo(string ccy1, string ccy2, string exchange)
{
var tradesForPair = await _databaseService.GetTradesForPair(ccy1, ccy2);
var profitAndLoss = ProfitCalculator.GetProfitAndLossForPair(tradesForPair, new Currency {
Base = ccy1, Terms = ccy2
});
var dollarAmount = await _priceService.GetDollarAmount(ccy1, profitAndLoss.Profit, exchange);
profitAndLoss.DollarProfit = dollarAmount;
await _databaseService.SaveProfitAndLoss(profitAndLoss);
return(profitAndLoss);
}
public async Task <ProfitAndLoss> GetPnLInfo(string ccy1, string ccy2)
{
var tradesForPair = await _databaseService.GetTradesForPair(ccy1, ccy2);
var profitAndLoss = ProfitCalculator.GetProfitAndLossForPair(tradesForPair, new Currency {
Base = ccy1, Terms = ccy2
});
// TODO: Ideally use each trade's exchange to get dollar amounts
var dollarAmount = await _priceService.GetDollarAmount(ccy1, profitAndLoss.Profit, Constants.Bittrex);
profitAndLoss.DollarProfit = dollarAmount;
await _databaseService.SaveProfitAndLoss(profitAndLoss);
return(profitAndLoss);
}
public async Task <ProfitAndLoss> GetPnLInfo(string ccy1, string ccy2, string exchange)
{
var tradesForPair = await _databaseService.GetTradesForPair(ccy1, ccy2);
var profitAndLoss = ProfitCalculator.GetProfitAndLossForPair(tradesForPair, new Currency {
Base = ccy1, Terms = ccy2
});
var reportingCurrency = _config.ReportingCurrency;
var reportingAmount = await _priceService.GetReportingAmount(ccy1, profitAndLoss.Profit, reportingCurrency, exchange);
profitAndLoss.ReportingProfit = reportingAmount;
profitAndLoss.ReportingCurrency = reportingCurrency;
await _databaseService.SaveProfitAndLoss(profitAndLoss);
return(profitAndLoss);
}
public void TestSellProfit()
{
_trades = new List<Trade>
{
CreateTrade("BTC", "XPM", 0.0025M, 0.00003911M, 0.01083815M, 277.11967321M, TradeSide.Buy,
new DateTime(2017, 09, 29, 20, 13, 5)),
CreateTrade("BTC", "XPM", 0.0025M, 0.00003980M, 0.00552158M, 138.73325317M, TradeSide.Buy,
new DateTime(2017, 09, 29, 19, 22, 56)),
CreateTrade("BTC", "XPM", 0.0025M, 0.00004084M, 0.00568006M, 139.08095555M, TradeSide.Buy,
new DateTime(2017, 09, 29, 19, 22, 56)),
};
var quanititySold = 300m;
var averageBuyPrice = ProfitCalculator.GetAveragePrice(_trades, quanititySold);
var profitPercent = ProfitCalculator.GetProfitForSell(0.02M, quanititySold, averageBuyPrice, quanititySold * averageBuyPrice);
Assert.AreEqual(70.23, profitPercent);
}
public async Task <TradesProfitResponse> Handle(TradeProfitQuery query)
{
var averagePrice = await _databaseService.GetBuyAveragePrice(query.BaseCcy, query.Terms, query.Exchange, query.Quantity);
if (averagePrice == 0m)
{
return(new TradesProfitResponse(null, null, null, null));
}
var totalCost = averagePrice * query.Quantity;
var profit = ProfitCalculator.GetProfitForSell(query.SellReturns, query.Quantity, averagePrice, totalCost);
var lastBought = await _databaseService.GetLastBoughtAsync(query.BaseCcy, query.Terms, query.Exchange);
decimal?btcProfit = query.SellReturns - totalCost;
decimal?dollarProfit = await _priceService.GetDollarAmount(query.BaseCcy, btcProfit.Value, query.Exchange);
return(new TradesProfitResponse(profit, btcProfit, dollarProfit, lastBought));
}
public async Task <TradesProfitResponse> Handle(TradeProfitQuery query)
{
var tradesForPairAndQuantity = _databaseService.GetBuysForPairAndQuantity(query.SellReturns, query.Quantity, query.BaseCcy, query.Terms);
if (tradesForPairAndQuantity.Count == 0)
{
return(new TradesProfitResponse(null, null, null, null));
}
ProfitCalculator.GetProfitForTrade(tradesForPairAndQuantity, query.SellReturns, query.Quantity, out decimal? totalCost, out decimal? profit, out DateTime lastBought);
if (profit.HasValue && totalCost.HasValue)
{
decimal?btcProfit = query.SellReturns - totalCost.Value;
decimal?dollarProfit = await _priceService.GetDollarAmount(btcProfit.Value);
return(new TradesProfitResponse(profit, btcProfit, dollarProfit, lastBought));
}
return(new TradesProfitResponse(null, null, null, null));
}
private void GeneratePlan_Executed(object sender, ExecutedRoutedEventArgs e)
{
Parameters.numberOfTowns = _attractions.Count;
Parameters.ChosenStart = Hotel.ActiveHotel.Id;
Parameters.distances = DistanceCalculator.GetDistances(Hotel.ActiveHotel, _attractions);
Parameters.profits = ProfitCalculator.GetProfits(_attractions);
Parameters.maxLength = int.Parse(TBLimit.Text);
Parameters.daysOfTrip = int.Parse(TBDays.Text);
Parameters.Notify = MockNotify;
Parameters.Reset();
var layer = MapInteractivity.GetRouteLineLayer(BingMap);
layer.Children.Clear();
PushPinLayer.Children.Clear();
_dayAttractions.Clear();
_dayRealRoads.Clear();
_dayStraightLines.Clear();
_tripPlan.Clear();
PlotHotels();
CBHotels.SelectedItem = Hotel.ActiveHotel;
Hotel.ActiveHotel.Pin.Background = new SolidColorBrush(Color.FromRgb(0, 0, 240));
Hotel.ActiveHotel.Pin.Visibility = Visibility.Visible;
var watch = System.Diagnostics.Stopwatch.StartNew();
Thread t = new Thread(() => _tripPlanner.GenerateRoutes());
t.Start();
t.Join();
watch.Stop();
LBAlgorithmExecutionTime.Content = watch.ElapsedMilliseconds / 1000.0 + " s";
UpdateTripPlan();
GenerateRouteLines();
DrawLines();
watch = System.Diagnostics.Stopwatch.StartNew();
GenerateRoutes();
DrawRoutes();
watch.Stop();
LBMapLoadingExecutionTime.Content = watch.ElapsedMilliseconds / 1000.0 + " s";
}
public void SetUp()
{
_calculator = new ProfitCalculator();
}
public async Task <BalanceInformation> GetBalance()
{
List <WalletBalance> balances;
try
{
var binanceClient = GetApi();
using (var user = new BinanceApiUser(_config.Key, _config.Secret))
{
var accountInfo = await binanceClient.GetAccountInfoAsync(user);
balances = BinanceConverter.BinanceToWalletBalances(accountInfo.Balances);
}
}
catch (Exception e)
{
_log.LogError("Error in getting balances from binance: " + e.Message);
throw;
}
var totalBtcBalance = 0m;
foreach (var balance in balances)
{
decimal price;
decimal btcAmount;
decimal averagePrice = 0m;
if (balance.Currency == _generalConfig.TradingCurrency)
{
btcAmount = balance.Balance;
price = 0m;
}
else if (balance.Currency == "USDT")
{
var marketPrice = await GetPrice("USDT", _generalConfig.TradingCurrency);
btcAmount = balance.Balance / marketPrice;
price = 0m;
}
else
{
var marketPrice = await GetPrice(_generalConfig.TradingCurrency, balance.Currency);
price = marketPrice;
btcAmount = (price * balance.Balance);
averagePrice =
await _databaseService.GetBuyAveragePrice(_generalConfig.TradingCurrency, balance.Currency, Constants.Binance, balance.Balance);
}
try
{
balance.PercentageChange = ProfitCalculator.PriceDifference(price, averagePrice);
}
catch
{
// There maybe a divide by 0 issue if we couldn't find the last trade. Its fine. Just print zero
balance.PercentageChange = 0;
}
balance.BtcAmount = btcAmount;
balance.Price = price;
totalBtcBalance = totalBtcBalance + balance.BtcAmount;
}
var lastBalance = await _databaseService.GetBalance24HoursAgo(Constants.Binance);
var dollarAmount = await GetDollarAmount(_generalConfig.TradingCurrency, totalBtcBalance);
var currentBalance = await _databaseService.AddBalance(totalBtcBalance, dollarAmount, Constants.Binance);
await _databaseService.AddWalletBalances(balances);
return(new BalanceInformation(currentBalance, lastBalance, Constants.Binance, balances));
}
/// <summary>
/// Starts the Profit Calculator.
/// </summary>
private void ShowProfitCalculator()
{
var profitCalculator = new ProfitCalculator();
profitCalculator.Show();
}
public async Task <BalanceInformation> GetBalance()
{
List <WalletBalance> balances;
try
{
var accountInfo = await _binanceWebsocketService.GetAccountInfoAsync();
if (accountInfo == null)
{
throw new Exception("Account info not had get from binance");
}
balances = BinanceConverter.BinanceToWalletBalances(accountInfo.Balances);
}
catch (Exception e)
{
_log.LogError("Error in getting balances from binance: " + e.Message);
throw;
}
var totalBtcBalance = 0m;
foreach (var balance in balances)
{
decimal price;
decimal btcAmount;
decimal averagePrice = 0m;
if (balance.Currency == _generalConfig.TradingCurrency)
{
btcAmount = balance.Balance;
price = 0m;
}
else if (balance.Currency == "USDT")
{
var marketPrice = await GetPrice("USDT", _generalConfig.TradingCurrency);
btcAmount = balance.Balance / marketPrice;
price = 0m;
}
else
{
var marketPrice = await GetPrice(_generalConfig.TradingCurrency, balance.Currency);
price = marketPrice;
btcAmount = (price * balance.Balance);
averagePrice =
await _databaseService.GetBuyAveragePrice(_generalConfig.TradingCurrency, balance.Currency, Constants.Binance, balance.Balance);
}
balance.PercentageChange = ProfitCalculator.PriceDifference(price, averagePrice);
balance.BtcAmount = btcAmount;
balance.Price = price;
totalBtcBalance = totalBtcBalance + balance.BtcAmount;
}
var lastBalance = await _databaseService.GetBalance24HoursAgo(Constants.Binance);
var dollarAmount = await GetDollarAmount(_generalConfig.TradingCurrency, totalBtcBalance);
var currentBalance = await _databaseService.AddBalance(totalBtcBalance, dollarAmount, Constants.Binance);
await _databaseService.AddWalletBalances(balances);
return(new BalanceInformation(currentBalance, lastBalance, Constants.Binance, balances));
}
public async Task <BalanceInformation> GetBalance()
{
List <WalletBalance> bittrexBalances;
try
{
var response = await _exchange.GetBalances();
bittrexBalances = TradeConverter.BittrexToWalletBalances(response);
}
catch (Exception e)
{
_log.LogError("Error in getting balances from bittrex: " + e.Message);
throw;
}
var totalBtcBalance = 0m;
foreach (var balance in bittrexBalances)
{
if (balance.Balance == 0)
{
continue;
}
decimal price;
decimal btcAmount;
decimal boughtPrice = 0m;
switch (balance.Currency)
{
case "BTC":
btcAmount = balance.Balance;
price = 1;
boughtPrice = 1;
break;
case "USDT":
price = await GetPrice(balance.Currency);
btcAmount = (balance.Balance / price);
var lastTradeForPair = _databaseService.GetLastTradeForPair(balance.Currency, Constants.Bittrex, TradeSide.Buy);
if (lastTradeForPair != null)
{
boughtPrice = lastTradeForPair.Limit;
}
break;
default:
price = await GetPrice(balance.Currency);
btcAmount = (price * balance.Balance);
var lastTradeForPair1 = _databaseService.GetLastTradeForPair(balance.Currency, Constants.Bittrex, TradeSide.Buy);
if (lastTradeForPair1 != null)
{
boughtPrice = lastTradeForPair1.Limit;
}
break;
}
try
{
balance.PercentageChange = ProfitCalculator.PriceDifference(price, boughtPrice);
}
catch
{
// There maybe a divide by 0 issue if we couldn't find the last trade. Its fine. Just print zero
balance.PercentageChange = 0;
}
balance.BtcAmount = btcAmount;
balance.Price = price;
totalBtcBalance = totalBtcBalance + btcAmount;
}
var lastBalance = _databaseService.GetBalance24HoursAgo(Constants.Bittrex);
var dollarAmount = await _priceService.GetDollarAmount(totalBtcBalance);
var currentBalance = _databaseService.AddBalance(totalBtcBalance, dollarAmount, Constants.Bittrex);
return(new BalanceInformation(currentBalance, lastBalance, Constants.Bittrex, bittrexBalances));
}
public async Task <BalanceInformation> GetBalance()
{
List <WalletBalance> bittrexBalances = new List <WalletBalance>();
try
{
using (var client = new BittrexClient(new BittrexClientOptions()
{
ApiCredentials = new ApiCredentials(_config.Key, _config.Secret)
}))
{
var response = await client.GetBalancesAsync();
if (response.Success)
{
bittrexBalances = BittrexConvertor.BittrexToWalletBalances(response.Data);
}
else
{
_log.LogWarning($"Bittrex returned an error {response.Error.Code} : {response.Error.Message}");
}
}
}
catch (Exception e)
{
_log.LogError("Error in getting balances from Bittrex: " + e.Message);
}
var totalBtcBalance = 0m;
foreach (var balance in bittrexBalances)
{
if (balance.Balance == 0)
{
continue;
}
decimal price;
decimal btcAmount;
decimal averagePrice = 0m;
if (balance.Currency == _generalConfig.TradingCurrency)
{
btcAmount = balance.Balance;
price = 0m;
}
else if (balance.Currency == "USDT")
{
var marketPrice = await GetPrice("USDT", _generalConfig.TradingCurrency);
btcAmount = balance.Balance / marketPrice;
price = 0m;
}
else
{
var marketPrice = await GetPrice(_generalConfig.TradingCurrency, balance.Currency);
price = marketPrice;
btcAmount = (price * balance.Balance);
averagePrice =
await _databaseService.GetBuyAveragePrice(_generalConfig.TradingCurrency, balance.Currency, Constants.Bittrex, balance.Balance);
}
try
{
balance.PercentageChange = ProfitCalculator.PriceDifference(price, averagePrice);
}
catch
{
// There maybe a divide by 0 issue if we couldn't find the last trade. Its fine. Just print zero
balance.PercentageChange = 0;
}
balance.BtcAmount = btcAmount;
balance.Price = price;
totalBtcBalance = totalBtcBalance + balance.BtcAmount;
}
var lastBalance = await _databaseService.GetBalance24HoursAgo(Constants.Bittrex);
var reportingAmount = await GetReportingAmount(_generalConfig.TradingCurrency, totalBtcBalance, _generalConfig.ReportingCurrency);
var currentBalance = await _databaseService.AddBalance(totalBtcBalance, reportingAmount, _generalConfig.ReportingCurrency, Constants.Bittrex);
await _databaseService.AddWalletBalances(bittrexBalances);
return(new BalanceInformation(currentBalance, lastBalance, Constants.Bittrex, bittrexBalances));
}
