public CryptoCoinSummary(CryptoExchangeBase exchange, CryptoCoin coin)
{
Symbol = coin.Symbol;
ExchangeName = exchange.Name;
HighestBid = coin.HighestBid;
LowestAsk = coin.LowestAsk;
}
private void saveButton_Click(object sender, EventArgs e)
{
CryptoCoin knownCoin = null;
if (coinCombo.SelectedIndex >= 0)
{
knownCoin = filteredCoins[coinCombo.SelectedIndex];
}
if (knownCoin == null)
{
CryptoCoin newCoin = new CryptoCoin();
newCoin.Name = coinCombo.Text;
newCoin.Algorithm = algoCombo.Text.ToAlgorithm();
using (CoinEditForm coinEditForm = new CoinEditForm(newCoin))
{
if (coinEditForm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
SelectedCoin = newCoin;
}
else
{
DialogResult = System.Windows.Forms.DialogResult.Cancel;
}
}
}
else
{
SelectedCoin = knownCoin;
}
}
private EngineConfiguration CreateEngineConfiguration()
{
EngineConfiguration engineConfiguration;
engineConfiguration = new EngineConfiguration();
engineConfiguration.XgminerConfiguration.MinerBackend = MinerBackend.Cgminer;
if (minerComboBox.SelectedIndex == 1)
{
engineConfiguration.XgminerConfiguration.MinerBackend = MinerBackend.Bfgminer;
}
CoinConfiguration coinConfiguration = new CoinConfiguration();
CryptoCoin coin = coins.Single(c => c.Name.Equals(coinComboBox.Text));
coinConfiguration.Coin = coin;
coinConfiguration.Enabled = true;
MiningPool miningPool = new MiningPool();
miningPool.Host = hostEdit.Text;
miningPool.Port = Int32.Parse(portEdit.Text);
miningPool.Username = usernameEdit.Text;
miningPool.Password = passwordEdit.Text;
coinConfiguration.Pools.Add(miningPool);
engineConfiguration.CoinConfigurations.Add(coinConfiguration);
return(engineConfiguration);
}
private void saveButton_Click(object sender, EventArgs e)
{
CryptoCoin knownCoin = null;
if (coinCombo.SelectedIndex >= 0)
{
knownCoin = sortedCoins[coinCombo.SelectedIndex];
}
if (knownCoin == null)
{
CryptoCoin newCoin = new CryptoCoin();
newCoin.Name = coinCombo.Text;
newCoin.Algorithm = Xgminer.Data.CoinAlgorithm.SHA256;
CoinEditForm coinEditForm = new CoinEditForm(newCoin);
if (coinEditForm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
SelectedCoin = newCoin;
}
else
{
DialogResult = System.Windows.Forms.DialogResult.Cancel;
}
}
else
{
SelectedCoin = knownCoin;
}
}
private void LoadSettings()
{
CryptoCoin coin = knownCoins.SingleOrDefault(c => c.Symbol.Equals(this.strategyConfiguration.MinimumThresholdSymbol));
if (coin != null)
{
thresholdSymbolCombo.Text = coin.Name;
}
singleCoinRadio.Checked = strategyConfiguration.SwitchStrategy == StrategyConfiguration.CoinSwitchStrategy.SingleMost;
multiCoinRadio.Checked = strategyConfiguration.SwitchStrategy == StrategyConfiguration.CoinSwitchStrategy.AllMost;
thresholdValueEdit.Text = strategyConfiguration.MinimumThresholdValue.ToString();
if (multiCoinRadio.Checked)
{
exceptionEdit.Text = strategyConfiguration.MineSingleMostOverrideValue.ToString();
}
profitabilityKindCombo.SelectedIndex = (int)strategyConfiguration.ProfitabilityKind;
baseCoinCombo.SelectedIndex = (int)strategyConfiguration.BaseCoin;
miningBasisCombo.SelectedIndex = (int)strategyConfiguration.MiningBasis;
intervalCombo.SelectedIndex = (int)applicationConfiguration.StrategyCheckInterval;
}
public CoinValueSummary(CryptoCoin coin)
{
Symbol = coin.Symbol;
HighestBid = coin.HighestBid;
LowestAsk = coin.LowestAsk;
Time = coin.Time;
}
private void AddCoinConfiguration(CryptoCoin cryptoCoin)
{
CoinConfiguration configuration = configurations.SingleOrDefault(c => c.Coin.Symbol.Equals(cryptoCoin.Symbol));
if (configuration != null)
{
coinListBox.SelectedIndex = configurations.IndexOf(configuration);
}
else
{
configuration = new CoinConfiguration();
configuration.Coin = knownCoins.SingleOrDefault(c => c.Symbol.Equals(cryptoCoin.Symbol, StringComparison.OrdinalIgnoreCase));
//user may have manually entered a coin
if (configuration.Coin == null)
{
configuration.Coin = new CryptoCoin();
configuration.Coin.Name = cryptoCoin.Name;
configuration.Coin.Symbol = cryptoCoin.Symbol;
configuration.Coin.Algorithm = cryptoCoin.Algorithm;
}
configuration.Pools.Add(new MiningPool());
configurations.Add(configuration);
coinListBox.Items.Add(configuration.Coin.Name);
coinListBox.SelectedIndex = configurations.IndexOf(configuration);
}
hostEdit.Focus();
}
protected override void Update(dynamic data, string symbol, string exchangeName = "")
{
CryptoCoin old = null;
var id = symbol.ToEnum(CryptoCoinId.NULL);
if (ExchangeData.ContainsKey(id))
{
old = ExchangeData[id].Clone( );
}
else
{
ExchangeData[id] = new CryptoCoin(symbol);
}
DeserializeData(data, id);
ApplyFees(id);
LastUpdate = DateTime.UtcNow;
OnNext(ExchangeData[id].Clone( ));
if (ExchangeData[id] != old)
{
OnChanged(ExchangeData[id]);
}
}
private void EditCurrentCoin()
{
if (coinListBox.SelectedIndex == -1)
{
return;
}
Engine.Data.Configuration.Coin currentConfiguration = configurations[coinListBox.SelectedIndex];
CryptoCoin workingCoin = new CryptoCoin();
ObjectCopier.CopyObject(currentConfiguration.CryptoCoin, workingCoin);
using (CoinEditForm coinEditForm = new CoinEditForm(workingCoin))
{
DialogResult dialogResult = coinEditForm.ShowDialog();
if (dialogResult == System.Windows.Forms.DialogResult.OK)
{
if (configurations.SingleOrDefault(c => c.CryptoCoin.Symbol.Equals(workingCoin.Symbol, StringComparison.OrdinalIgnoreCase)) == null)
{
ObjectCopier.CopyObject(workingCoin, currentConfiguration.CryptoCoin);
coinListBox.Items[coinListBox.SelectedIndex] = workingCoin.Name;
}
else
{
//don't create a dupe
MessageBox.Show(String.Format("A configuration for {0} already exists.", workingCoin.Symbol),
"Duplicate Configuration", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
}
}
/// <summary>
/// Updates the coin as sold. Populates the sold coin's SOLD & Original properties, such as SoldCurrency, SoldPrice, and TotalSoldPriceUSD,
/// based on the original coin. Basically, update soldCoin to have both bought & sold values.
/// </summary>
/// <param name="originalCoin">The original coin that was bought</param>
/// <param name="soldCoin">The sold version of that original coin</param>
/// <param name="updateOnlySoldPrice">
/// If we don't know the bought price, set bought details as 0, and only update the sold price. The coin could have been transferred over and sold here;
/// which could be the reason we don't know bought price.
/// </param>
/// <returns>Sold version of the coin with original bought/paid price</returns>
private static CryptoCoin UpdateSoldCoinsFieldFromOriginal(CryptoCoin originalCoin, CryptoCoin soldCoin, bool updateOnlySoldPrice = false)
{
// If soldCoin's sold prices are not already populated, that means their sold values resides in the bought properties.
// So, move bought properties over to the sold property.
if (soldCoin.SoldCoinCurrency == Types.CoinCurrency.Unknown)
{
soldCoin.SoldCoinCurrency = soldCoin.CoinCurrency;
}
if (soldCoin.SoldPricePerUnit.GetValueOrDefault() == 0)
{
soldCoin.SoldPricePerUnit = soldCoin.PricePerUnit;
}
if (soldCoin.TotalSoldPricePaidUSD.GetValueOrDefault() == 0)
{
soldCoin.TotalSoldPricePaidUSD = soldCoin.TotalPricePaidUSD;
}
if (!updateOnlySoldPrice)
{
// originalCoin still holds the original BOUGHT price for this sold coin.
soldCoin.CoinCurrency = originalCoin.CoinCurrency;
soldCoin.PricePerUnit = originalCoin.PricePerUnit;
soldCoin.TotalPricePaidUSD = originalCoin.TotalPricePaidUSD;
}
else
{
// Unknown bought price, but it's a sold coin so we know the sold price. (Could be tranferred over).
soldCoin.PricePerUnit = 0;
soldCoin.TotalPricePaidUSD = 0;
}
return(soldCoin);
}
private static CoinDisplay ToCoinDisplay(this CryptoCoin item, Types.CoinCurrency currency)
{
// Why manually and not auto-mapper? Tons of data, and most used method. So Mapster can get slow.
// Also, You cannot cast a child object into a parent object. Need to create a new instance of it or use reflection.
return(new CoinDisplay
{
CoinId = item.CoinId,
Symbol = item.Symbol,
Shares = item.Shares,
OrderDate = item.OrderDate,
PricePerUnit = item.PricePerUnit,
CoinCurrency = item.CoinCurrency,
TotalPricePaidUSD = item.TotalPricePaidUSD,
OrderType = item.OrderType,
Notes = item.Notes,
Exchange = item.Exchange,
SoldCoinCurrency = item.SoldCoinCurrency,
SoldPricePerUnit = item.SoldPricePerUnit,
TotalSoldPricePaidUSD = item.TotalSoldPricePaidUSD,
PortfolioId = item.PortfolioId,
MarketCoin = item.MarketCoin,
GeneratedPricePerUnitETH = item.GeneratedPricePerUnitETH,
CurrentUSDPriceOfBTC = item.CurrentUSDPriceOfBTC,
CurrentUSDPriceOfETH = item.CurrentUSDPriceOfETH,
OrderedDateUSDPriceOfBTC = item.OrderedDateUSDPriceOfBTC,
OrderedDateUSDPriceOfETH = item.OrderedDateUSDPriceOfETH,
DisplayCurrency = currency,
IsCurrentlyCombined = item.IsCurrentlyCombined
});
}
private void saveButton_Click(object sender, EventArgs e)
{
string coinName = coinCombo.Text;
CryptoCoin knownCoin = sortedCoins.SingleOrDefault(c => c.Name.Equals(coinName, StringComparison.OrdinalIgnoreCase));
if (knownCoin == null)
{
CryptoCoin newCoin = new CryptoCoin();
newCoin.Name = coinName;
newCoin.Algorithm = Xgminer.CoinAlgorithm.SHA256;
CoinEditForm coinEditForm = new CoinEditForm(newCoin);
if (coinEditForm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
SelectedCoin = newCoin;
}
else
{
DialogResult = System.Windows.Forms.DialogResult.Cancel;
}
}
else
{
SelectedCoin = knownCoin;
}
}
public override async void OnNext(CryptoCoin coin)
{
if (!Symbols.Contains(coin.Symbol))
{
return;
}
if (!LastSignificantPrice.ContainsKey(coin.Symbol))
{
LastSignificantPrice[coin.Symbol] = coin;
}
var change = PriceChange.Difference(coin, LastSignificantPrice[coin.Symbol]);
var percentage = Math.Abs(change.Percentage);
if (percentage >= Threshold)
{
var previous = LastSignificantPrice[coin.Symbol].Clone( );
LastSignificantPrice[coin.Symbol] = coin.Clone( );
await OnTriggerAsync(previous.Clone( ), coin.Clone( )).ConfigureAwait(false);
Trigger?.Invoke(this, previous.Clone( ), coin.Clone( ));
}
}
protected override void Update(dynamic data,
string symbol)
{
symbol = CleanAndExtractSymbol(symbol);
if (ExchangeData.TryGetValue(symbol, out var old))
{
old = old.Clone( );
}
else
{
ExchangeData[symbol] = new CryptoCoin(symbol);
}
DeserializeData(data, symbol);
Markets.AddOrUpdate(ExchangeData[symbol]);
LastUpdate = DateTime.UtcNow;
OnNext(ExchangeData[symbol]);
if (!ExchangeData[symbol].HasSameValues(old))
{
OnChanged(ExchangeData[symbol]);
}
}
private void SaveSettings()
{
if (string.IsNullOrEmpty(thresholdSymbolCombo.Text))
{
this.strategyConfiguration.MinimumThresholdSymbol = string.Empty;
}
else
{
CryptoCoin coin = knownCoins.SingleOrDefault(c => c.Name.Equals(thresholdSymbolCombo.Text));
if (coin != null)
{
this.strategyConfiguration.MinimumThresholdSymbol = coin.Symbol;
}
}
if (singleCoinRadio.Checked)
{
strategyConfiguration.SwitchStrategy = StrategyConfiguration.CoinSwitchStrategy.SingleMost;
}
else
{
strategyConfiguration.SwitchStrategy = StrategyConfiguration.CoinSwitchStrategy.AllMost;
}
if (string.IsNullOrEmpty(thresholdValueEdit.Text))
{
this.strategyConfiguration.MinimumThresholdValue = null;
}
else
{
double percentage;
if (double.TryParse(thresholdValueEdit.Text, out percentage))
{
strategyConfiguration.MinimumThresholdValue = percentage;
}
}
if (multiCoinRadio.Checked)
{
if (string.IsNullOrEmpty(exceptionEdit.Text))
{
this.strategyConfiguration.MineSingleMostOverrideValue = null;
}
else
{
double percentage;
if (double.TryParse(exceptionEdit.Text, out percentage))
{
strategyConfiguration.MineSingleMostOverrideValue = percentage;
}
}
}
strategyConfiguration.ProfitabilityKind = (StrategyConfiguration.CoinProfitabilityKind)profitabilityKindCombo.SelectedIndex;
strategyConfiguration.BaseCoin = (Coinchoose.Api.BaseCoin)baseCoinCombo.SelectedIndex;
strategyConfiguration.MiningBasis = (StrategyConfiguration.CoinMiningBasis)miningBasisCombo.SelectedIndex;
applicationConfiguration.StrategyCheckInterval = (ApplicationConfiguration.CoinStrategyCheckInterval)intervalCombo.SelectedIndex;
}
private void LoadSettings()
{
CryptoCoin coin = knownCoins.SingleOrDefault(c => c.Symbol.Equals(this.strategyConfiguration.MinimumThresholdSymbol));
if (coin != null)
{
thresholdSymbolCombo.Text = coin.Name;
}
singleCoinRadio.Checked = strategyConfiguration.SwitchStrategy == StrategyConfiguration.CoinSwitchStrategy.SingleMost;
multiCoinRadio.Checked = strategyConfiguration.SwitchStrategy == StrategyConfiguration.CoinSwitchStrategy.AllMost;
thresholdValueEdit.Text = strategyConfiguration.MinimumThresholdValue.ToString();
if (multiCoinRadio.Checked)
{
exceptionEdit.Text = strategyConfiguration.MineSingleMostOverrideValue.ToString();
}
profitabilityKindCombo.SelectedIndex = (int)strategyConfiguration.ProfitabilityKind;
if (applicationConfiguration.UseCoinWarzApi)
{
baseCoinCombo.SelectedIndex = 0;
baseCoinCombo.Enabled = false;
}
else
{
baseCoinCombo.SelectedIndex = (int)strategyConfiguration.BaseCoin;
}
miningBasisCombo.SelectedIndex = (int)strategyConfiguration.MiningBasis;
intervalCombo.SelectedIndex = (int)applicationConfiguration.StrategyCheckInterval;
if (applicationConfiguration.SuggestCoinsToMine)
{
if (applicationConfiguration.SuggestionsAlgorithm == ApplicationConfiguration.CoinSuggestionsAlgorithm.SHA256)
{
suggestionsCombo.SelectedIndex = 1;
}
else if (applicationConfiguration.SuggestionsAlgorithm == ApplicationConfiguration.CoinSuggestionsAlgorithm.Scrypt)
{
suggestionsCombo.SelectedIndex = 2;
}
else if (applicationConfiguration.SuggestionsAlgorithm == (ApplicationConfiguration.CoinSuggestionsAlgorithm.SHA256 | ApplicationConfiguration.CoinSuggestionsAlgorithm.Scrypt))
{
suggestionsCombo.SelectedIndex = 3;
}
else
{
suggestionsCombo.SelectedIndex = 0;
}
}
else
{
suggestionsCombo.SelectedIndex = 0;
}
}
private async Task OnChangedAsync(ICryptoExchange exchange,
CryptoCoin coin)
{
foreach (var service in Services)
{
await service.OnChangedAsync(exchange, coin).ConfigureAwait(false);
}
Changed?.Invoke(exchange, coin);
}
private void SaveSettings()
{
if (string.IsNullOrEmpty(minCoinCombo.Text))
{
this.strategyConfiguration.MinimumProfitabilitySymbol = string.Empty;
}
else
{
CryptoCoin coin = knownCoins.SingleOrDefault(c => c.Name.Equals(minCoinCombo.Text));
if (coin != null)
{
this.strategyConfiguration.MinimumProfitabilitySymbol = coin.Symbol;
}
}
if (singleCoinRadio.Checked)
{
strategyConfiguration.SwitchStrategy = StrategyConfiguration.CoinSwitchStrategy.SingleMostProfitable;
}
else
{
strategyConfiguration.SwitchStrategy = StrategyConfiguration.CoinSwitchStrategy.AllMostProfitable;
}
if (string.IsNullOrEmpty(minPercentageEdit.Text))
{
this.strategyConfiguration.MinimumProfitabilityPercentage = null;
}
else
{
double percentage;
if (double.TryParse(minPercentageEdit.Text, out percentage))
{
strategyConfiguration.MinimumProfitabilityPercentage = percentage;
}
}
if (multiCoinRadio.Checked)
{
if (string.IsNullOrEmpty(exceptionEdit.Text))
{
this.strategyConfiguration.MineMostProfitableOverridePercentage = null;
}
else
{
double percentage;
if (double.TryParse(exceptionEdit.Text, out percentage))
{
strategyConfiguration.MineMostProfitableOverridePercentage = percentage;
}
}
}
strategyConfiguration.ProfitabilityBasis = (StrategyConfiguration.CoinProfitabilityBasis)proftabilityBasisCombo.SelectedIndex;
applicationConfiguration.StrategyCheckInterval = (ApplicationConfiguration.CoinStrategyCheckInterval)intervalCombo.SelectedIndex;
}
public override Task OnChangedAsync(ICryptoExchange exchange,
CryptoCoin coin)
{
lock ( consoleLock )
{
Console.Write($"{exchange.Name,-12}", Color.DodgerBlue);
Console.WriteLineStyled($" | {coin}", StyleSheet);
}
return(Task.CompletedTask);
}
public static async Task <ResultsItem> UpdateUserCoinAsync(CryptoCoin coin, PegaUser user)
{
var validateRequest = IsValidDBRequest(user, coin.PortfolioId, validatePortfolio: true);
if (!validateRequest.IsSuccess)
{
return(validateRequest);
}
return(await CryptoRepository.UpdateUserCoinAsync(coin));
}
public static PriceChange Difference(CryptoCoin newCoin,
CryptoCoin oldCoin)
=> new PriceChange
{
Value = newCoin.Rate - oldCoin.Rate,
Percentage = (newCoin.Rate - oldCoin.Rate) /
(newCoin.Rate + oldCoin.Rate) *
2m,
TimeDiff = newCoin.Time - oldCoin.Time,
AbsoluteTime = newCoin.Time
};
private Engine.Data.Configuration.Coin AddCoinConfiguration(CryptoCoin cryptoCoin)
{
//don't allow two configurations for the same coin symbol
Engine.Data.Configuration.Coin configuration = configurations.SingleOrDefault(c => c.CryptoCoin.Symbol.Equals(cryptoCoin.Symbol, StringComparison.OrdinalIgnoreCase));
if (configuration == null)
//don't allow two configurations for the same coin name
configuration = configurations.SingleOrDefault(c => c.CryptoCoin.Name.Equals(cryptoCoin.Name, StringComparison.OrdinalIgnoreCase));
if (configuration != null)
{
coinListBox.SelectedIndex = configurations.IndexOf(configuration);
}
else
{
configuration = new Engine.Data.Configuration.Coin();
configuration.CryptoCoin = knownCoins.SingleOrDefault(c => c.Symbol.Equals(cryptoCoin.Symbol, StringComparison.OrdinalIgnoreCase));
//user may have manually entered a coin
if (configuration.CryptoCoin == null)
{
configuration.CryptoCoin = new CryptoCoin();
configuration.CryptoCoin.Name = cryptoCoin.Name;
configuration.CryptoCoin.Symbol = cryptoCoin.Symbol;
configuration.CryptoCoin.Algorithm = cryptoCoin.Algorithm;
}
//at this point, configuration.CryptoCoin.Algorithm is the CoinAlgorithm.FullName
//that is how data from Coin API is stored
//but coin configurations are based on CoinAlgorithm.Name
string algorithmFullName = configuration.CryptoCoin.Algorithm;
CoinAlgorithm algorithm = MinerFactory.Instance.Algorithms.SingleOrDefault(a => a.FullName.Equals(algorithmFullName, StringComparison.OrdinalIgnoreCase));
configuration.CryptoCoin.Algorithm = algorithm.Name;
MiningPool miningPool = new MiningPool()
{
Host = Data.Configuration.PoolDefaults.HostPrefix,
Port = Data.Configuration.PoolDefaults.Port
};
configuration.Pools.Add(miningPool);
configurations.Add(configuration);
coinListBox.Items.Add(configuration.CryptoCoin.Name);
coinListBox.SelectedIndex = configurations.IndexOf(configuration);
}
hostEdit.Focus();
hostEdit.SelectionStart = hostEdit.SelectionLength;
return configuration;
}
public async Task <JsonResult> DeleteCoin(int coinId, int portfolioId)
{
CryptoCoin fetchedCoin = await CryptoLogic.GetSingleCoinByUser(coinId, CurrentUser);
if (fetchedCoin?.PortfolioId != portfolioId)
{
return(Json(ResultsItem.Error(Lang.PortfolioNotFound)));
}
return(Json(await CryptoLogic.DeleteUserCoinsAsync(new List <CryptoCoin> {
new CryptoCoin {
CoinId = coinId, PortfolioId = portfolioId
}
}, CurrentUser)));
}
public void MarkCryptoCoinAsFavorite(User user, CryptoCoin cryptoCoin)
{
var isCoinAlreadyMarked = user.FavoriteCoins.Any(c => c.Name.Equals(cryptoCoin.Name));
if (!isCoinAlreadyMarked)
{
using (_uow)
{
user.FavoriteCoins.Add(cryptoCoin);
_uow.UserRepository.SaveOrAdd(user);
_uow.Commit();
}
}
}
public void Process(CryptoCoin coin)
{
if (!LastSignificantPrice.ContainsKey(coin.Symbol))
{
LastSignificantPrice[coin.Symbol] = coin.Clone( );
}
var change = coin - LastSignificantPrice[coin.Symbol];
var percentage = Math.Abs(change.Percentage);
if (percentage >= Threshold)
{
Changed?.BeginInvoke(Exchange, LastSignificantPrice[coin.Symbol], coin, null, null);
LastSignificantPrice[coin.Symbol] = coin.Clone( );
}
}
public decimal GetCryptoCoinAvarageValue(CryptoCoin cryptoCoin, string currency)
{
var dicCoinAveragePrice = _cryptoCoinGateway.GetCoinAveragePrice(cryptoCoin);
if (dicCoinAveragePrice.Count == 0)
{
return(0);
}
if (!dicCoinAveragePrice.ContainsKey(currency))
{
return(0);
}
return(dicCoinAveragePrice[currency]);
}
/// <summary>
/// Gets the price per unit of the coin based on currency. For example, Coin-USD: $500, Coin-BTC: .1
/// </summary>
public static decimal GetPricePerUnitOfCoin(CryptoCoin coin, Types.CoinCurrency currency)
{
if (currency == Types.CoinCurrency.BTC)
{
return(coin.MarketCoin.CurrentSymbolPriceBTC);
}
if (currency == Types.CoinCurrency.USD)
{
return(coin.MarketCoin.CurrentSymbolPriceUSD);
}
if (currency == Types.CoinCurrency.ETH)
{
return(coin.CurrentSymbolPriceETH);
}
return(0);
}
public async Task <decimal> GetCurrentCoinPrice(string symbol)
{
Types.CoinCurrency predictedCurrency = CryptoLogic.GenerateCoinCurrencyFromSymbol(symbol);
if (predictedCurrency == Types.CoinCurrency.Unknown)
{
return(0);
}
CryptoCoin coin = (await UpdateCoinsCurrentPrice(new List <CryptoCoin> {
new CryptoCoin {
Symbol = symbol.ToUpperInvariant()
}
}, false)).First();
return(CryptoLogic.GetPricePerUnitOfCoin(coin, predictedCurrency));
}
private async Task SendSubscriptionReply(long id, CryptoExchangeBase ex, CryptoCoin oldValue, CryptoCoin newValue)
{
var change = newValue - oldValue;
var builder = new StringBuilder( );
builder
.AppendLine($"{ex.Name,-14} {newValue.Symbol}")
.AppendLine($"Current Price: {ex[newValue.Symbol].Average:C}")
.AppendLine($"Change: {change.Value.ToCurrency ( )}")
.AppendLine($"Change %: {change.Percentage:P}")
.AppendLine($"in {change.TimeDiff:dd\\:hh\\:mm\\:ss}");
SaveSubscriptions( );
await bot.SendTextMessageAsync(id, $"```\n{builder}\n```", ParseMode.Markdown);
}
private Engine.Data.Configuration.Coin AddCoinConfiguration(CryptoCoin cryptoCoin)
{
//don't allow two configurations for the same coin symbol
Engine.Data.Configuration.Coin configuration = configurations.SingleOrDefault(c => c.CryptoCoin.Symbol.Equals(cryptoCoin.Symbol, StringComparison.OrdinalIgnoreCase));
if (configuration == null)
{
//don't allow two configurations for the same coin name
configuration = configurations.SingleOrDefault(c => c.CryptoCoin.Name.Equals(cryptoCoin.Name, StringComparison.OrdinalIgnoreCase));
}
if (configuration != null)
{
coinListBox.SelectedIndex = configurations.IndexOf(configuration);
}
else
{
configuration = new Engine.Data.Configuration.Coin();
configuration.CryptoCoin = knownCoins.SingleOrDefault(c => c.Symbol.Equals(cryptoCoin.Symbol, StringComparison.OrdinalIgnoreCase));
//user may have manually entered a coin
if (configuration.CryptoCoin == null)
{
configuration.CryptoCoin = new CryptoCoin();
configuration.CryptoCoin.Name = cryptoCoin.Name;
configuration.CryptoCoin.Symbol = cryptoCoin.Symbol;
configuration.CryptoCoin.Algorithm = cryptoCoin.Algorithm;
}
MiningPool miningPool = new MiningPool()
{
Host = "stratum+tcp://",
Port = 3333
};
configuration.Pools.Add(miningPool);
configurations.Add(configuration);
coinListBox.Items.Add(configuration.CryptoCoin.Name);
coinListBox.SelectedIndex = configurations.IndexOf(configuration);
}
hostEdit.Focus();
hostEdit.SelectionStart = hostEdit.SelectionLength;
return(configuration);
}
private Engine.Data.Configuration.Engine CreateEngineConfiguration()
{
Engine.Data.Configuration.Engine engineConfiguration;
engineConfiguration = new Engine.Data.Configuration.Engine();
Engine.Data.Configuration.Coin coinConfiguration = new Engine.Data.Configuration.Coin();
CryptoCoin coin = null;
//no Internet connection - only BTC and LTC were available
if (coins.Count == 0)
{
coin = new CryptoCoin();
coin.Name = coinComboBox.Text;
if (coin.Name.Equals(KnownCoins.LitecoinName, StringComparison.OrdinalIgnoreCase))
{
coin.Algorithm = CoinAlgorithm.Scrypt;
coin.Symbol = KnownCoins.LitecoinSymbol;
}
else
{
coin.Algorithm = CoinAlgorithm.SHA256;
coin.Symbol = KnownCoins.BitcoinSymbol;
}
}
else
{
coin = coins.Single(c => c.Name.Equals(coinComboBox.Text));
}
coinConfiguration.CryptoCoin = coin;
coinConfiguration.Enabled = true;
MiningPool miningPool = new MiningPool();
miningPool.Host = hostEdit.Text;
miningPool.Port = Int32.Parse(portEdit.Text);
miningPool.Username = usernameEdit.Text;
miningPool.Password = passwordEdit.Text;
coinConfiguration.Pools.Add(miningPool);
engineConfiguration.CoinConfigurations.Add(coinConfiguration);
return(engineConfiguration);
}
private void LoadKnownCoinsFromCoinStats()
{
foreach (CoinInformation item in coinApiInformation)
{
//find existing known coin or create a knew one
CryptoCoin knownCoin = knownCoins.SingleOrDefault(c => c.Symbol.Equals(item.Symbol));
if (knownCoin == null)
{
knownCoin = new CryptoCoin();
this.knownCoins.Add(knownCoin);
}
knownCoin.Symbol = item.Symbol;
knownCoin.Name = item.Name;
knownCoin.Algorithm = item.Algorithm.ToAlgorithm();
}
SaveKnownCoinsToFile();
}
private void EditCurrentCoin()
{
if (coinListBox.SelectedIndex == -1)
return;
Engine.Data.Configuration.Coin currentConfiguration = configurations[coinListBox.SelectedIndex];
CryptoCoin workingCoin = new CryptoCoin();
ObjectCopier.CopyObject(currentConfiguration.CryptoCoin, workingCoin);
using (CoinEditForm coinEditForm = new CoinEditForm(workingCoin))
{
DialogResult dialogResult = coinEditForm.ShowDialog();
if (dialogResult == System.Windows.Forms.DialogResult.OK)
{
MultiMiner.Engine.Data.Configuration.Coin existingConfiguration =
configurations.SingleOrDefault(c => (c != currentConfiguration)
&& c.CryptoCoin.Symbol.Equals(workingCoin.Symbol, StringComparison.OrdinalIgnoreCase));
if (existingConfiguration == null)
{
ObjectCopier.CopyObject(workingCoin, currentConfiguration.CryptoCoin);
coinListBox.Items[coinListBox.SelectedIndex] = workingCoin.Name;
}
else
{
//don't create a dupe
MessageBox.Show(String.Format("A configuration for {0} already exists.", workingCoin.Symbol),
"Duplicate Configuration", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
}
}
public CoinEditForm(CryptoCoin cryptoCoin)
{
InitializeComponent();
this.cryptoCoin = cryptoCoin;
}
private void saveButton_Click(object sender, EventArgs e)
{
CryptoCoin knownCoin = null;
if (coinCombo.SelectedIndex >= 0)
knownCoin = filteredCoins[coinCombo.SelectedIndex];
if (knownCoin == null)
{
CryptoCoin newCoin = new CryptoCoin();
newCoin.Name = coinCombo.Text;
newCoin.Algorithm = GetSelectedAlgorithm().Name;
using (CoinEditForm coinEditForm = new CoinEditForm(newCoin))
{
if (coinEditForm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
SelectedCoin = newCoin;
else
DialogResult = System.Windows.Forms.DialogResult.Cancel;
}
}
else
{
SelectedCoin = knownCoin;
}
}
private Engine.Data.Configuration.Engine CreateEngineConfiguration()
{
Engine.Data.Configuration.Engine engineConfiguration;
engineConfiguration = new Engine.Data.Configuration.Engine();
Engine.Data.Configuration.Coin coinConfiguration = new Engine.Data.Configuration.Coin();
CryptoCoin coin = null;
//no Internet connection - only BTC and LTC were available
if (coins.Count == 0)
{
coin = new CryptoCoin();
coin.Name = coinComboBox.Text;
if (coin.Name.Equals(KnownCoins.LitecoinName, StringComparison.OrdinalIgnoreCase))
{
coin.Algorithm = CoinAlgorithm.Scrypt;
coin.Symbol = KnownCoins.LitecoinSymbol;
}
else
{
coin.Algorithm = CoinAlgorithm.SHA256;
coin.Symbol = KnownCoins.BitcoinSymbol;
}
}
else
{
coin = coins.Single(c => c.Name.Equals(coinComboBox.Text));
}
coinConfiguration.CryptoCoin = coin;
coinConfiguration.Enabled = true;
MiningPool miningPool = new MiningPool();
miningPool.Host = hostEdit.Text;
miningPool.Port = Int32.Parse(portEdit.Text);
miningPool.Username = usernameEdit.Text;
miningPool.Password = passwordEdit.Text;
coinConfiguration.Pools.Add(miningPool);
engineConfiguration.CoinConfigurations.Add(coinConfiguration);
return engineConfiguration;
}
private void LoadKnownCoinsFromCoinStats()
{
foreach (CoinInformation item in coinApiInformation)
{
//find existing known coin or create a knew one
CryptoCoin knownCoin = knownCoins.SingleOrDefault(c => c.Symbol.Equals(item.Symbol));
if (knownCoin == null)
{
knownCoin = new CryptoCoin();
this.knownCoins.Add(knownCoin);
}
knownCoin.Symbol = item.Symbol;
knownCoin.Name = item.Name;
//needs to be a case insensitive check to work with both CoinChoose and CoinWarz
if (item.Algorithm.ToLower().Contains(AlgorithmNames.Scrypt.ToLower()))
knownCoin.Algorithm = CoinAlgorithm.Scrypt;
else
knownCoin.Algorithm = CoinAlgorithm.SHA256;
}
SaveKnownCoinsToFile();
}
