public static void ParseTextForVersionInformation(string text, MultiMiner.Xgminer.Api.Data.VersionInformation versionInformation)
{
List<string> responseParts = text.Split('|').ToList();
Dictionary<string, string> keyValuePairs = GetDictionaryFromTextChunk(responseParts[0]);
//check for key-value pairs, seen Count == 0 with user API logs
if (keyValuePairs.Count > 0)
{
versionInformation.Name = keyValuePairs["Msg"].Replace(" versions", String.Empty);
versionInformation.Description = keyValuePairs["Description"];
keyValuePairs = GetDictionaryFromTextChunk(responseParts[1]);
string key = "CGMiner";
if (keyValuePairs.ContainsKey(key))
versionInformation.MinerVersion = keyValuePairs[key];
else
{
// SGMiner 4.0 broke compatibility with the CGMiner RPC API
// Version 5.0 fixed the issue - this work-around is for 4.0
// Request :"version"
// Response:"STATUS=S,When=1415068731,Code=22,Msg=SGMiner versions,Description=sgminer 4.1.0|VERSION,SGMiner=4.1.0,API=3.1|\u0000"
key = "SGMiner";
if (keyValuePairs.ContainsKey(key))
versionInformation.MinerVersion = keyValuePairs[key];
}
versionInformation.ApiVersion = keyValuePairs["API"];
}
}
public MinerSettingsForm(MultiMiner.Engine.Data.Configuration.Xgminer minerConfiguration, Application applicationConfiguration)
{
InitializeComponent();
this.minerConfiguration = minerConfiguration;
this.workingMinerConfiguration = ObjectCopier.CloneObject<MultiMiner.Engine.Data.Configuration.Xgminer, MultiMiner.Engine.Data.Configuration.Xgminer>(minerConfiguration);
this.applicationConfiguration = applicationConfiguration;
this.workingApplicationConfiguration = ObjectCopier.CloneObject<Application, Application>(applicationConfiguration);
}
public void StoreTo(MultiMiner.Engine.Configuration.StrategyConfiguration newConfiguration)
{
newConfiguration.AutomaticallyMineCoins = this.MineProfitableCoins;
newConfiguration.MineSingleMostOverrideValue = this.MineMostProfitableOverridePercentage;
newConfiguration.MinimumThresholdSymbol = this.MinimumProfitabilitySymbol;
newConfiguration.MinimumThresholdValue = this.MinimumProfitabilityPercentage;
newConfiguration.ProfitabilityKind = (MultiMiner.Engine.Configuration.StrategyConfiguration.CoinProfitabilityKind)this.ProfitabilityBasis;
newConfiguration.SwitchStrategy = (MultiMiner.Engine.Configuration.StrategyConfiguration.CoinSwitchStrategy)this.SwitchStrategy;
}
public SettingsForm(Data.Configuration.Application applicationConfiguration, MultiMiner.Engine.Data.Configuration.Xgminer minerConfiguration,
Paths pathConfiguration)
{
InitializeComponent();
this.minerConfiguration = minerConfiguration;
this.applicationConfiguration = applicationConfiguration;
this.pathConfiguration = pathConfiguration;
}
public ProxySettingsForm(MultiMiner.Engine.Data.Configuration.Xgminer minerConfiguration)
{
InitializeComponent();
this.minerConfiguration = minerConfiguration;
this.proxyDescriptorBindingSource.DataSource = minerConfiguration.StratumProxies;
proxyListBox.DataSource = proxyDescriptorBindingSource;
proxyListBox.DisplayMember = "StratumPort";
}
private static void PopulateXgminerVersion(MultiMiner.Xgminer.MinerBackend minerBackend, Label targetLabel)
{
string xgminerName = MinerPath.GetMinerName(minerBackend);
string xgminerPath = MinerPath.GetPathToInstalledMiner(minerBackend);
string xgminerVersion = String.Empty;
if (File.Exists(xgminerPath))
xgminerVersion = Xgminer.Installer.GetInstalledMinerVersion(minerBackend, xgminerPath);
if (string.IsNullOrEmpty(xgminerVersion))
targetLabel.Text = String.Format("{0} not installed", xgminerName);
else
targetLabel.Text = String.Format("{0} {1} installed", xgminerName, xgminerVersion);
}
public static void ParseTextForVersionInformation(string text, MultiMiner.Xgminer.Api.Data.VersionInformation versionInformation)
{
List<string> textChunks = text.Split('|').ToList();
Dictionary<string, string> keyValuePairs = GetDictionaryFromTextChunk(textChunks[0]);
versionInformation.Name = keyValuePairs["Msg"].Replace(" versions", String.Empty);
versionInformation.Description = keyValuePairs["Description"];
keyValuePairs = GetDictionaryFromTextChunk(textChunks[1]);
versionInformation.MinerVersion = keyValuePairs["CGMiner"];
versionInformation.ApiVersion = keyValuePairs["API"];
}
private void PopulateMiningStatistics(MultiMiner.MobileMiner.Api.MiningStatistics miningStatistics, DeviceInformationResponse deviceInformation,
string coinName)
{
miningStatistics.MinerName = "MultiMiner";
miningStatistics.CoinName = coinName;
CoinConfiguration coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.Coin.Name.Equals(coinName));
CryptoCoin coin = coinConfiguration.Coin;
miningStatistics.CoinSymbol = coin.Symbol;
if (coin.Algorithm == CoinAlgorithm.Scrypt)
miningStatistics.Algorithm = "scrypt";
else if (coin.Algorithm == CoinAlgorithm.SHA256)
miningStatistics.Algorithm = "SHA-256";
miningStatistics.PopulateFrom(deviceInformation);
}
private void NotifyCoinToMine(MultiMiner.Coin.Api.CoinInformation coin)
{
string value = coin.AverageProfitability.ToString(".#") + "%";
string noun = "average profitability";
switch (engineConfiguration.StrategyConfiguration.MiningBasis)
{
case StrategyConfiguration.CoinMiningBasis.Difficulty:
value = coin.Difficulty.ToString(".####");
noun = "difficulty";
break;
case StrategyConfiguration.CoinMiningBasis.Price:
value = coin.Price.ToString(".########");
noun = "price";
break;
}
string infoUrl = coinApiContext.GetInfoUrl(engineConfiguration.StrategyConfiguration.BaseCoin);
notificationsControl.AddNotification(coin.Symbol,
String.Format("Consider mining {0} ({1} {2})",
coin.Symbol, value, noun), () =>
{
Process.Start(String.Format("https://www.google.com/search?q={0}+{1}+mining+pools",
coin.Symbol, coin.Name));
}, infoUrl);
}
private void PopulateMobileMinerStatistics(MultiMiner.MobileMiner.Data.MiningStatistics miningStatistics, DeviceInformation deviceInformation,
string coinName)
{
miningStatistics.MinerName = "MultiMiner";
miningStatistics.CoinName = coinName;
Engine.Data.Configuration.Coin coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.CryptoCoin.Name.Equals(coinName));
CryptoCoin coin = coinConfiguration.CryptoCoin;
miningStatistics.CoinSymbol = coin.Symbol;
//MobileMiner currently only supports SHA and Scrypt
//attempt to treat them as "Families" for now
if ((coin.Algorithm == CoinAlgorithm.SHA256) ||
(coin.Algorithm == CoinAlgorithm.Keccak) ||
(coin.Algorithm == CoinAlgorithm.Groestl))
//SHA family algorithms grouped together
miningStatistics.Algorithm = AlgorithmNames.SHA256;
else
//assume Scrypt for rest until MobileMiner supports more
miningStatistics.Algorithm = AlgorithmNames.Scrypt;
miningStatistics.PopulateFrom(deviceInformation);
}
private string GetFriendlyDeviceName(MultiMiner.Xgminer.Data.Device device)
{
string result = device.Name;
DeviceViewModel deviceViewModel = localViewModel.Devices.SingleOrDefault(d => d.Equals(device));
if ((deviceViewModel != null) && !String.IsNullOrEmpty(deviceViewModel.FriendlyName))
result = deviceViewModel.FriendlyName;
return result;
}
public DevicesService(MultiMiner.Engine.Data.Configuration.Xgminer minerConfiguration)
{
this.xgminerConfiguration = minerConfiguration;
}
private void PopulateMinerStatsForRow(MultiMiner.Xgminer.Api.DeviceInformation deviceInformation, DataGridViewRow row)
{
row.Cells[temperatureColumn.Index].Value = deviceInformation.Temperature;
row.Cells[hashRateColumn.Index].Value = deviceInformation.AverageHashrate;
row.Cells[acceptedColumn.Index].Value = deviceInformation.AcceptedShares;
row.Cells[rejectedColumn.Index].Value = deviceInformation.RejectedShares;
row.Cells[errorsColumn.Index].Value = deviceInformation.HardwareErrors;
row.Cells[utilityColumn.Index].Value = deviceInformation.Utility;
row.Cells[intensityColumn.Index].Value = deviceInformation.Intensity;
}
private int GetRowIndexForDeviceInformation(MultiMiner.Xgminer.Api.DeviceInformation deviceInformation)
{
int index = 0;
int rowIndex = -1;
for (int i = 0; i < devices.Count; i++)
{
if ((deviceInformation.Kind.Equals("GPU") && (devices[i].Kind == DeviceKind.GPU))
|| (!deviceInformation.Kind.Equals("GPU") && (devices[i].Kind != DeviceKind.GPU)))
{
if (index == deviceInformation.Index)
{
rowIndex = i;
break;
}
index++;
}
}
return rowIndex;
}
private static void PopulateMiningStatsFromDeviceInfo(MultiMiner.MobileMiner.Api.MiningStatistics miningStatistics, MultiMiner.Xgminer.Api.DeviceInformation deviceInformation)
{
miningStatistics.AcceptedShares = deviceInformation.AcceptedShares;
miningStatistics.AverageHashrate = deviceInformation.AverageHashrate;
miningStatistics.CurrentHashrate = deviceInformation.CurrentHashrate;
miningStatistics.Enabled = deviceInformation.Enabled;
miningStatistics.FanPercent = deviceInformation.FanPercent;
miningStatistics.FanSpeed = deviceInformation.FanSpeed;
miningStatistics.GpuActivity = deviceInformation.GpuActivity;
miningStatistics.GpuClock = deviceInformation.GpuClock;
miningStatistics.GpuVoltage = deviceInformation.GpuVoltage;
miningStatistics.HardwareErrors = deviceInformation.HardwareErrors;
miningStatistics.Index = deviceInformation.Index;
miningStatistics.Intensity = deviceInformation.Intensity;
miningStatistics.Kind = deviceInformation.Kind;
miningStatistics.MemoryClock = deviceInformation.MemoryClock;
miningStatistics.PowerTune = deviceInformation.PowerTune;
miningStatistics.RejectedShares = deviceInformation.RejectedShares;
miningStatistics.Status = deviceInformation.Status;
miningStatistics.Temperature = deviceInformation.Temperature;
miningStatistics.Utility = deviceInformation.Utility;
}
