private void diffMultEdit_Validated(object sender, EventArgs e)
{
string algorithmName = SelectedAlgorithmName();
CoinAlgorithm algorithm = MinerFactory.Instance.GetAlgorithm(algorithmName);
algorithm.DifficultyMultiplier = Convert.ToDouble(diffMultEdit.Text);
}
private CoinAlgorithm GetSelectedAlgorithm()
{
string algorithmName = algoCombo.Text.Replace(" ", String.Empty);
CoinAlgorithm algorithm = MinerFactory.Instance.GetAlgorithm(algorithmName);
return(algorithm);
}
private void UpdateAlgoMultipliers(string algorithmName)
{
CoinAlgorithm algorithm = MinerFactory.Instance.GetAlgorithm(algorithmName);
poolMultEdit.Text = algorithm.PoolMultiplier.ToString();
diffMultEdit.Text = algorithm.DifficultyMultiplier.ToString();
}
private void algoListView_BeforeLabelEdit(object sender, System.Windows.Forms.LabelEditEventArgs e)
{
string algorithmName = SelectedAlgorithmName();
CoinAlgorithm algorithm = MinerFactory.Instance.GetAlgorithm(algorithmName);
e.CancelEdit = algorithm.BuiltIn;
}
private void kernelArgsEdit_Validated(object sender, EventArgs e)
{
string algorithmName = SelectedAlgorithmName();
CoinAlgorithm algorithm = MinerFactory.Instance.GetAlgorithm(algorithmName);
string minerName = minerCombo.Text;
algorithm.MinerArguments[minerName] = kernelArgsEdit.Text;
}
private List <Device> ListDevices(bool prettyNames, CoinAlgorithm algorithm)
{
string arguments = MinerParameter.DeviceList;
bool redirectOutput = true;
string serialArg = GetListSerialArguments();
arguments = String.Format("{0} {1}", arguments, serialArg);
//include Scrypt ASICs
if (algorithm == CoinAlgorithm.Scrypt)
{
arguments = String.Format("{0} {1}", arguments, MinerParameter.Scrypt);
}
//include the args specified by the user so we pickup manual devices (e.g. Avalon)
arguments = String.Format("{0} {1}", arguments, minerConfiguration.ScanArguments);
//ADL mismatch with OCL can cause an error / exception, disable ADL when enumerating devices
//user can then disable for mining in-app using settings
//this also prevents nice names for GPUs
//arguments = arguments + " --no-adl";
//this must be done async, with 70+ devices doing this synchronous
//locks up the process
Process minerProcess = StartMinerProcess(arguments, redirectOutput, false, "", false);
List <string> output = new List <string>();
minerProcess.OutputDataReceived += (sender, e) =>
{
if (e.Data != null)
{
string s = e.Data;
output.Add(s);
}
};
minerProcess.Start();
minerProcess.BeginOutputReadLine();
//calling BeginErrorReadLine here is *required* on at least one user's machine
minerProcess.BeginErrorReadLine();
//wait 5 minutes - scans may take a long time
minerProcess.WaitForExit(5 * 60 * 1000);
List <Device> result = new List <Device>();
DeviceListParser.ParseTextForDevices(output, result);
if (prettyNames)
{
MakeNamesPretty(result);
}
return(result);
}
private Engine.Data.Configuration.Coin AddCoinConfiguration(PoolGroup poolGroup)
{
//don't allow two configurations for the same coin symbol
Engine.Data.Configuration.Coin configuration = configurations.SingleOrDefault(c => c.PoolGroup.Id.Equals(poolGroup.Id, StringComparison.OrdinalIgnoreCase));
if (configuration == null)
{
//don't allow two configurations for the same coin name
configuration = configurations.SingleOrDefault(c => c.PoolGroup.Name.Equals(poolGroup.Name, StringComparison.OrdinalIgnoreCase));
}
if (configuration != null)
{
coinListBox.SelectedIndex = configurations.IndexOf(configuration);
}
else
{
configuration = new Engine.Data.Configuration.Coin();
configuration.PoolGroup = knownCoins.SingleOrDefault(c => c.Id.Equals(poolGroup.Id, StringComparison.OrdinalIgnoreCase));
//user may have manually entered a coin or may be using a Multipool
if (configuration.PoolGroup == null)
{
configuration.PoolGroup = new PoolGroup();
ObjectCopier.CopyObject(poolGroup, configuration.PoolGroup);
}
//at this point, configuration.CryptoCoin.Algorithm MAY be the CoinAlgorithm.FullName
//that is how data from Coin API is stored
//but coin configurations are based on CoinAlgorithm.Name
CoinAlgorithm algorithm = MinerFactory.Instance.Algorithms.SingleOrDefault(a =>
a.FullName.Equals(configuration.PoolGroup.Algorithm, StringComparison.OrdinalIgnoreCase));
if (algorithm != null)
{
configuration.PoolGroup.Algorithm = algorithm.Name;
}
MiningPool miningPool = new MiningPool()
{
Host = UX.Data.Configuration.PoolDefaults.HostPrefix,
Port = UX.Data.Configuration.PoolDefaults.Port
};
configuration.Pools.Add(miningPool);
configurations.Add(configuration);
coinListBox.Items.Add(configuration.PoolGroup.Name);
coinListBox.SelectedIndex = configurations.IndexOf(configuration);
}
hostEdit.Focus();
hostEdit.SelectionStart = hostEdit.SelectionLength;
return(configuration);
}
public CoinAlgorithm RegisterAlgorithm(string name, string fullName)
{
CoinAlgorithm algorithm = new CoinAlgorithm()
{
Name = name,
FullName = fullName
};
Algorithms.Add(algorithm);
return(algorithm);
}
public MinerDescriptor GetMiner(DeviceKind deviceKind, string algorithmName, SerializableDictionary <string, string> miners)
{
CoinAlgorithm algorithm = GetAlgorithm(algorithmName);
if (algorithm == null)
{
//algorithm for name not found
return(null);
}
return(GetMiner(deviceKind, algorithm, miners));
}
private void RemoveSelectedAlgorithm()
{
string algorithmName = SelectedAlgorithmName();
CoinAlgorithm algorithm = MinerFactory.Instance.GetAlgorithm(algorithmName);
DialogResult dialogResult = MessageBox.Show("Remove the selected algorithm?", algorithmName, MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (dialogResult == System.Windows.Forms.DialogResult.Yes)
{
MinerFactory.Instance.Algorithms.Remove(algorithm);
algoListView.Items.Remove(algoListView.SelectedItems[0]);
}
}
public CoinAlgorithm RegisterAlgorithm(string name, string fullName, CoinAlgorithm.AlgorithmFamily family)
{
CoinAlgorithm algorithm = new CoinAlgorithm()
{
Name = name,
FullName = fullName,
Family = family
};
Algorithms.Add(algorithm);
return(algorithm);
}
//configurations save with algorithm FullName instead of Name
private void FixWrongAlgorithmsFromCoinWarz()
{
List <CoinAlgorithm> algorithms = MinerFactory.Instance.Algorithms;
IEnumerable <Coin> issues = CoinConfigurations.Where(
cc => algorithms.Any(a => a.FullName.Equals(cc.PoolGroup.Algorithm, StringComparison.OrdinalIgnoreCase) &&
!a.Name.Equals(cc.PoolGroup.Algorithm, StringComparison.OrdinalIgnoreCase)));
foreach (Coin issue in issues)
{
CoinAlgorithm algorithm = algorithms.Single(a => a.FullName.Equals(issue.PoolGroup.Algorithm, StringComparison.OrdinalIgnoreCase));
issue.PoolGroup.Algorithm = algorithm.Name;
}
}
private void argAlgoCombo_SelectedIndexChanged(object sender, EventArgs e)
{
CoinAlgorithm algorithm = (CoinAlgorithm)algoArgCombo.SelectedIndex;
if (workingMinerConfiguration.AlgorithmFlags.ContainsKey(algorithm))
{
algoArgEdit.Text = workingMinerConfiguration.AlgorithmFlags[algorithm];
}
else
{
algoArgEdit.Text = String.Empty;
}
}
private void argAlgoCombo_SelectedIndexChanged(object sender, EventArgs e)
{
CoinAlgorithm algorithm = (CoinAlgorithm)Enum.Parse(typeof(CoinAlgorithm), algoArgCombo.Text.Replace(" ", String.Empty));
if (workingMinerConfiguration.AlgorithmFlags.ContainsKey(algorithm))
{
algoArgEdit.Text = workingMinerConfiguration.AlgorithmFlags[algorithm];
}
else
{
algoArgEdit.Text = String.Empty;
}
}
private void UpdateKernelArguments(string algorithmName)
{
CoinAlgorithm algorithm = MinerFactory.Instance.GetAlgorithm(algorithmName);
string minerName = minerCombo.Text;
if (algorithm.MinerArguments.ContainsKey(minerName))
{
kernelArgsEdit.Text = algorithm.MinerArguments[minerName];
}
else
{
kernelArgsEdit.Text = String.Empty;
}
}
public IActionResult GetConAlgorithm(Guid id)
{
try
{
CoinAlgorithm coinAlgorithm = context.CoinAlgorithms.Find(id);
if (coinAlgorithm == null)
return NotFound();
return Ok(coinAlgorithm);
}
catch (Exception ex)
{
return StatusCode(500);
}
}
private void algoListView_AfterLabelEdit(object sender, LabelEditEventArgs e)
{
if (e.Label == null)
{
//edit was canceled
return;
}
string algorithmName = SelectedAlgorithmName();
CoinAlgorithm algorithm = MinerFactory.Instance.GetAlgorithm(algorithmName);
algorithm.Name = e.Label;
algorithm.FullName = e.Label;
}
public IActionResult DeleteCoinAlgorithm(Guid id)
{
try
{
CoinAlgorithm coinAlgorithm = context.CoinAlgorithms.Find(id);
if (coinAlgorithm == null)
return NotFound();
context.CoinAlgorithms.Remove(coinAlgorithm);
context.SaveChanges();
return Ok();
}
catch (Exception ex)
{
return StatusCode(500);
}
}
public MinerDescriptor GetMiner(DeviceKind deviceKind, CoinAlgorithm algorithm, SerializableDictionary <CoinAlgorithm, string> miners)
{
if (deviceKind != DeviceKind.GPU)
{
return(GetDefaultMiner());
}
if (miners.ContainsKey(algorithm))
{
return(Miners.Single(m => m.Name.Equals(miners[algorithm], StringComparison.OrdinalIgnoreCase)));
}
else
{
return(DefaultMiners[algorithm]);
}
}
//configurations saved with algorithm Name with spaces
private void FixWrongAlgorithmsFromCoinChoose()
{
IEnumerable <Coin> potentialIssues = CoinConfigurations.Where(cc => !cc.PoolGroup.Algorithm.Replace(" ", String.Empty).Equals(cc.PoolGroup.Algorithm));
foreach (Coin potentialIssue in potentialIssues)
{
string algorithmName = potentialIssue.PoolGroup.Algorithm.Replace(" ", String.Empty);
CoinAlgorithm algorithm = MinerFactory.Instance.GetAlgorithm(algorithmName);
if (algorithm != null)
{
//only make the change if there is an algorithm found
//a user may add an algorithm with a space in the name - we don't want to change that
potentialIssue.PoolGroup.Algorithm = algorithm.Name;
}
}
}
public IActionResult PostCoinALgorithm([FromBody]CoinAlgorithm coinAlgorithm)
{
try
{
if (context.Algorithms.Find(coinAlgorithm.AlgorithmId) == null || context.Coins.Find(coinAlgorithm.CoinId) == null)
return BadRequest();
context.CoinAlgorithms.Add(coinAlgorithm);
context.SaveChanges();
string url = Url.ActionContext.HttpContext.Request.Path;
return Created(url, coinAlgorithm);
}
catch (Exception ex)
{
return StatusCode(500);
}
}
public IActionResult PutCoinAlgorithm([FromBody]CoinAlgorithm coinAlgorithm)
{
try
{
if (context.Algorithms.Find(coinAlgorithm.AlgorithmId) == null || context.Coins.Find(coinAlgorithm.CoinId) == null)
return BadRequest();
if (context.CoinAlgorithms.Any(ca => ca.Id == coinAlgorithm.Id))
return NotFound();
context.CoinAlgorithms.Update(coinAlgorithm);
context.SaveChanges();
return Ok(coinAlgorithm);
}
catch (Exception ex)
{
return StatusCode(500);
}
}
private void PopulateCoinCombo()
{
CoinAlgorithm algorithm = GetSelectedAlgorithm();
filteredCoins = sortedCoins.Where(sc => (sc.Kind == PoolGroup.PoolGroupKind.SingleCoin) &&
sc.Algorithm.Equals(algorithm.FullName, StringComparison.OrdinalIgnoreCase)).ToList();
coinCombo.Text = String.Empty;
coinCombo.Items.Clear();
foreach (PoolGroup sortedCoin in filteredCoins)
{
coinCombo.Items.Add(String.Format("{0} ({1})", sortedCoin.Name, sortedCoin.Id));
}
if (coinCombo.Items.Count > 0)
{
coinCombo.SelectedIndex = 0;
}
}
public MinerDescriptor GetMiner(DeviceKind deviceKind, CoinAlgorithm algorithm, SerializableDictionary <string, string> miners)
{
if (deviceKind != DeviceKind.GPU)
{
return(GetDefaultMiner());
}
string algorithmName = algorithm.Name;
if (miners.ContainsKey(algorithmName))
{
return(Miners.Single(m => m.Name.Equals(miners[algorithmName], StringComparison.OrdinalIgnoreCase)));
}
if (algorithm.DefaultMiner != null)
{
return(Miners.Single(m => m.Name.Equals(algorithm.DefaultMiner, StringComparison.OrdinalIgnoreCase)));
}
return(null);
}
private void algoListView_SelectedIndexChanged(object sender, EventArgs e)
{
bool algoSelected = algoListView.SelectedItems.Count > 0;
minerCombo.Enabled = algoSelected;
kernelArgsEdit.Enabled = algoSelected;
addButton.Enabled = true;
if (algoSelected)
{
PopulateMinerCombo();
string algorithmName = SelectedAlgorithmName();
CoinAlgorithm algorithm = MinerFactory.Instance.GetAlgorithm(algorithmName);
removeButton.Enabled = !algorithm.BuiltIn;
}
else
{
removeButton.Enabled = false;
}
}
public static string ToAlgorithmName(this CoinAlgorithm algorithm)
{
switch (algorithm)
{
case CoinAlgorithm.SHA256:
return(AlgorithmNames.SHA256);
case CoinAlgorithm.Scrypt:
return(AlgorithmNames.Scrypt);
case CoinAlgorithm.ScryptJane:
return(AlgorithmNames.ScryptJane);
case CoinAlgorithm.ScryptN:
return(AlgorithmNames.ScryptN);
case CoinAlgorithm.X11:
return(AlgorithmNames.X11);
case CoinAlgorithm.X13:
return(AlgorithmNames.X13);
case CoinAlgorithm.X14:
return(AlgorithmNames.X14);
case CoinAlgorithm.X15:
return(AlgorithmNames.X15);
case CoinAlgorithm.Quark:
return(AlgorithmNames.Quark);
case CoinAlgorithm.Groestl:
return(AlgorithmNames.Groestl);
case CoinAlgorithm.Keccak:
return(AlgorithmNames.Keccak);
}
return(AlgorithmNames.SHA256);
}
private void PopulateMinerCombo()
{
CoinAlgorithm algorithm = (CoinAlgorithm)Enum.Parse(typeof(CoinAlgorithm), algoCombo.Text.Replace(" ", String.Empty));
minerCombo.Items.Clear();
IEnumerable <string> miners = MinerFactory.Instance.Miners
.Select(m => m.Name)
.OrderBy(m => m);
foreach (string miner in miners)
{
minerCombo.Items.Add(miner);
}
string currentMiner = MinerFactory.Instance.DefaultMiners[algorithm].Name;
if (minerConfiguration.AlgorithmMiners.ContainsKey(algorithm))
{
currentMiner = minerConfiguration.AlgorithmMiners[algorithm];
}
minerCombo.SelectedItem = currentMiner;
}
public MinerDescriptor GetMiner(DeviceKind deviceKind, CoinAlgorithm algorithm, SerializableDictionary <string, string> miners)
{
if (deviceKind != DeviceKind.GPU)
{
return(GetDefaultMiner());
}
string algorithmName = algorithm.Name;
MinerDescriptor result = null;
if (miners.ContainsKey(algorithmName))
{
// SingleOrDefault - the user may have a config file with a backend
// miner registered that no longer exists in their Miners\ folder
result = Miners.SingleOrDefault(m => m.Name.Equals(miners[algorithmName], StringComparison.OrdinalIgnoreCase));
}
if ((result == null) && (algorithm.DefaultMiner != null))
{
result = Miners.Single(m => m.Name.Equals(algorithm.DefaultMiner, StringComparison.OrdinalIgnoreCase));
}
return(result);
}
private void PopulateMinerCombo()
{
string algorithmName = SelectedAlgorithmName();
CoinAlgorithm algorithm = MinerFactory.Instance.GetAlgorithm(algorithmName);
minerCombo.Items.Clear();
IEnumerable <string> miners = MinerFactory.Instance.Miners
.Select(m => m.Name)
.OrderBy(m => m);
foreach (string miner in miners)
{
minerCombo.Items.Add(miner);
}
string currentMiner = algorithm.DefaultMiner;
if (minerConfiguration.AlgorithmMiners.ContainsKey(algorithmName))
{
currentMiner = minerConfiguration.AlgorithmMiners[algorithmName];
}
minerCombo.SelectedItem = currentMiner;
}
private static void RegisterCustomAlgorithms()
{
string dataFilePath = AlgorithmConfigurationsFileName();
List <CoinAlgorithm> existingAlgorithms = MinerFactory.Instance.Algorithms;
if (File.Exists(dataFilePath))
{
List <CoinAlgorithm> customAlgorithms = ConfigurationReaderWriter.ReadConfiguration <List <CoinAlgorithm> >(dataFilePath);
foreach (CoinAlgorithm customAlgorithm in customAlgorithms)
{
CoinAlgorithm existingAlgorithm = existingAlgorithms.SingleOrDefault(ea => ea.Name.Equals(customAlgorithm.Name, StringComparison.OrdinalIgnoreCase));
if (existingAlgorithm != null)
{
//don't override our Family - user may have added an algo before we support it
//don't override BuiltIn - user may have added an algo before we support it
ObjectCopier.CopyObject(customAlgorithm, existingAlgorithm, "Family", "BuiltIn");
}
else
{
existingAlgorithms.Add(customAlgorithm);
}
}
}
}
private double GetTotalHashrate(CoinAlgorithm algorithm)
{
double result = 0.00;
if (miningEngine.Mining)
{
//only include Visible devices
foreach (DeviceViewModel device in localViewModel.Devices.Where(d => d.Visible))
{
if ((device.Coin != null) && (device.Coin.Algorithm == algorithm))
result += device.AverageHashrate;
}
}
return result;
}
