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; }