Example #1
0
        public async Task SwichMostProfitableGroupUpMethod(Dictionary <AlgorithmType, NiceHashSMA> NiceHashData, bool log = true)
        {
#if (SWITCH_TESTING)
            MiningDevice.SetNextTest();
#endif
            List <MiningPair> profitableDevices = new List <MiningPair>();
            double            CurrentProfit     = 0.0d;
            double            PrevStateProfit   = 0.0d;
            foreach (var device in _miningDevices)
            {
                // calculate profits
                device.CalculateProfits(NiceHashData);
                // check if device has profitable algo
                if (device.HasProfitableAlgo())
                {
                    profitableDevices.Add(device.GetMostProfitablePair());
                    CurrentProfit   += device.GetCurrentMostProfitValue;
                    PrevStateProfit += device.GetPrevMostProfitValue;
                }
            }

            // print profit statuses
            if (log)
            {
                StringBuilder stringBuilderFull = new StringBuilder();
                stringBuilderFull.AppendLine("Current device profits:");
                foreach (var device in _miningDevices)
                {
                    StringBuilder stringBuilderDevice = new StringBuilder();
                    stringBuilderDevice.AppendLine(String.Format("\tProfits for {0} ({1}):", device.Device.UUID, device.Device.GetFullName()));
                    foreach (var algo in device.Algorithms)
                    {
                        stringBuilderDevice.AppendLine(String.Format("\t\tPROFIT = {0}\t(SPEED = {1}\t\t| NHSMA = {2})\t[{3}]",
                                                                     algo.CurrentProfit.ToString(DOUBLE_FORMAT),                                          // Profit
                                                                     algo.AvaragedSpeed + (algo.IsDual() ? "/" + algo.SecondaryAveragedSpeed : ""),       // Speed
                                                                     algo.CurNhmSMADataVal + (algo.IsDual() ? "/" + algo.SecondaryCurNhmSMADataVal : ""), // NiceHashData
                                                                     algo.AlgorithmStringID                                                               // Name
                                                                     ));
                    }
                    // most profitable
                    stringBuilderDevice.AppendLine(String.Format("\t\tMOST PROFITABLE ALGO: {0}, PROFIT: {1}",
                                                                 device.GetMostProfitableString(),
                                                                 device.GetCurrentMostProfitValue.ToString(DOUBLE_FORMAT)));
                    stringBuilderFull.AppendLine(stringBuilderDevice.ToString());
                }
                Helpers.ConsolePrint(TAG, stringBuilderFull.ToString());
            }

            // check if should mine
            // Only check if profitable inside this method when getting SMA data, cheching during mining is not reliable
            if (CheckIfShouldMine(CurrentProfit, log) == false)
            {
                foreach (var device in _miningDevices)
                {
                    device.SetNotMining();
                }
                return;
            }

            // check profit threshold
            Helpers.ConsolePrint(TAG, String.Format("PrevStateProfit {0}, CurrentProfit {1}", PrevStateProfit, CurrentProfit));
            if (PrevStateProfit > 0 && CurrentProfit > 0)
            {
                double a = Math.Max(PrevStateProfit, CurrentProfit);
                double b = Math.Min(PrevStateProfit, CurrentProfit);
                //double percDiff = Math.Abs((PrevStateProfit / CurrentProfit) - 1);
                double percDiff = ((a - b)) / b;
                if (percDiff < ConfigManager.GeneralConfig.SwitchProfitabilityThreshold)
                {
                    // don't switch
                    Helpers.ConsolePrint(TAG, String.Format("Will NOT switch profit diff is {0}, current threshold {1}", percDiff, ConfigManager.GeneralConfig.SwitchProfitabilityThreshold));
                    // RESTORE OLD PROFITS STATE
                    foreach (var device in _miningDevices)
                    {
                        device.RestoreOldProfitsState();
                    }
                    if (!Miner.SHOULD_START_DONATING)
                    {
                        return;
                    }
                }
                else
                {
                    Helpers.ConsolePrint(TAG, String.Format("Will SWITCH profit diff is {0}, current threshold {1}", percDiff, ConfigManager.GeneralConfig.SwitchProfitabilityThreshold));
                }
            }

            // group new miners
            Dictionary <string, List <MiningPair> > newGroupedMiningPairs = new Dictionary <string, List <MiningPair> >();
            // group devices with same supported algorithms
            {
                var currentGroupedDevices = new List <GroupedDevices>();
                for (int first = 0; first < profitableDevices.Count; ++first)
                {
                    var firstDev = profitableDevices[first].Device;
                    // check if is in group
                    bool isInGroup = false;
                    foreach (var groupedDevices in currentGroupedDevices)
                    {
                        if (groupedDevices.Contains(firstDev.UUID))
                        {
                            isInGroup = true;
                            break;
                        }
                    }
                    // if device is not in any group create new group and check if other device should group
                    if (isInGroup == false)
                    {
                        var newGroup    = new GroupedDevices();
                        var miningPairs = new List <MiningPair>()
                        {
                            profitableDevices[first]
                        };
                        newGroup.Add(firstDev.UUID);
                        for (int second = first + 1; second < profitableDevices.Count; ++second)
                        {
                            // check if we should group
                            var firstPair  = profitableDevices[first];
                            var secondPair = profitableDevices[second];
                            if (GroupingLogic.ShouldGroup(firstPair, secondPair))
                            {
                                var secondDev = profitableDevices[second].Device;
                                newGroup.Add(secondDev.UUID);
                                miningPairs.Add(profitableDevices[second]);
                            }
                        }
                        currentGroupedDevices.Add(newGroup);
                        newGroupedMiningPairs[CalcGroupedDevicesKey(newGroup)] = miningPairs;
                    }
                }
            }
            //bool IsMinerStatsCheckUpdate = false;
            {
                // check which groupMiners should be stopped and which ones should be started and which to keep running
                Dictionary <string, GroupMiner> toStopGroupMiners   = new Dictionary <string, GroupMiner>();
                Dictionary <string, GroupMiner> toRunNewGroupMiners = new Dictionary <string, GroupMiner>();
                Dictionary <string, GroupMiner> noChangeGroupMiners = new Dictionary <string, GroupMiner>();
                // check what to stop/update
                foreach (string runningGroupKey in _runningGroupMiners.Keys)
                {
                    if (newGroupedMiningPairs.ContainsKey(runningGroupKey) == false)
                    {
                        // runningGroupKey not in new group definately needs to be stopped and removed from curently running
                        toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey];
                    }
                    // If we need to start donating, stop everything
                    else if (!Miner.IS_DONATING && Miner.SHOULD_START_DONATING)
                    {
                        toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey];

                        var        miningPairs   = newGroupedMiningPairs[runningGroupKey];
                        var        newAlgoType   = GetMinerPairAlgorithmType(miningPairs);
                        GroupMiner newGroupMiner = null;
                        if (newAlgoType == AlgorithmType.DaggerHashimoto)
                        {
                            if (_ethminerNVIDIAPaused != null && _ethminerNVIDIAPaused.Key == runningGroupKey)
                            {
                                newGroupMiner = _ethminerNVIDIAPaused;
                            }
                            if (_ethminerAMDPaused != null && _ethminerAMDPaused.Key == runningGroupKey)
                            {
                                newGroupMiner = _ethminerAMDPaused;
                            }
                        }
                        if (newGroupMiner == null)
                        {
                            newGroupMiner = new GroupMiner(miningPairs, runningGroupKey);
                        }
                        toRunNewGroupMiners[runningGroupKey] = newGroupMiner;
                        Miner.IS_DONATING = true;
                    }
                    else if (Miner.IS_DONATING && Miner.SHOULD_STOP_DONATING)
                    {
                        toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey];

                        var        miningPairs   = newGroupedMiningPairs[runningGroupKey];
                        var        newAlgoType   = GetMinerPairAlgorithmType(miningPairs);
                        GroupMiner newGroupMiner = null;
                        if (newAlgoType == AlgorithmType.DaggerHashimoto)
                        {
                            if (_ethminerNVIDIAPaused != null && _ethminerNVIDIAPaused.Key == runningGroupKey)
                            {
                                newGroupMiner = _ethminerNVIDIAPaused;
                            }
                            if (_ethminerAMDPaused != null && _ethminerAMDPaused.Key == runningGroupKey)
                            {
                                newGroupMiner = _ethminerAMDPaused;
                            }
                        }
                        if (newGroupMiner == null)
                        {
                            newGroupMiner = new GroupMiner(miningPairs, runningGroupKey);
                        }
                        toRunNewGroupMiners[runningGroupKey] = newGroupMiner;

                        Miner.DonationStart = Miner.DonationStart.Add(Miner.DonateEvery);
                        Miner.IS_DONATING   = false;
                    }
                    else
                    {
                        // runningGroupKey is contained but needs to check if mining algorithm is changed
                        var miningPairs = newGroupedMiningPairs[runningGroupKey];
                        var newAlgoType = GetMinerPairAlgorithmType(miningPairs);
                        if (newAlgoType != AlgorithmType.NONE && newAlgoType != AlgorithmType.INVALID)
                        {
                            // if algoType valid and different from currently running update
                            if (newAlgoType != _runningGroupMiners[runningGroupKey].DualAlgorithmType)
                            {
                                // remove current one and schedule to stop mining
                                toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey];
                                // create new one TODO check if DaggerHashimoto
                                GroupMiner newGroupMiner = null;
                                if (newAlgoType == AlgorithmType.DaggerHashimoto)
                                {
                                    if (_ethminerNVIDIAPaused != null && _ethminerNVIDIAPaused.Key == runningGroupKey)
                                    {
                                        newGroupMiner = _ethminerNVIDIAPaused;
                                    }
                                    if (_ethminerAMDPaused != null && _ethminerAMDPaused.Key == runningGroupKey)
                                    {
                                        newGroupMiner = _ethminerAMDPaused;
                                    }
                                }
                                if (newGroupMiner == null)
                                {
                                    newGroupMiner = new GroupMiner(miningPairs, runningGroupKey);
                                }
                                toRunNewGroupMiners[runningGroupKey] = newGroupMiner;
                            }
                            else
                            {
                                noChangeGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey];
                            }
                        }
                    }
                }
                // check brand new
                foreach (var kvp in newGroupedMiningPairs)
                {
                    var key         = kvp.Key;
                    var miningPairs = kvp.Value;
                    if (_runningGroupMiners.ContainsKey(key) == false)
                    {
                        GroupMiner newGroupMiner = new GroupMiner(miningPairs, key);
                        toRunNewGroupMiners[key] = newGroupMiner;
                    }
                }

                if ((toStopGroupMiners.Values.Count > 0) || (toRunNewGroupMiners.Values.Count > 0))
                {
                    StringBuilder stringBuilderPreviousAlgo = new StringBuilder();
                    StringBuilder stringBuilderCurrentAlgo  = new StringBuilder();
                    StringBuilder stringBuilderNoChangeAlgo = new StringBuilder();

                    // stop old miners
                    foreach (var toStop in toStopGroupMiners.Values)
                    {
                        stringBuilderPreviousAlgo.Append(String.Format("{0}: {1}, ", toStop.DevicesInfoString, toStop.AlgorithmType));

                        toStop.Stop();
                        _runningGroupMiners.Remove(toStop.Key);
                        // TODO check if daggerHashimoto and save
                        if (toStop.AlgorithmType == AlgorithmType.DaggerHashimoto)
                        {
                            if (toStop.DeviceType == DeviceType.NVIDIA)
                            {
                                _ethminerNVIDIAPaused = toStop;
                            }
                            else if (toStop.DeviceType == DeviceType.AMD)
                            {
                                _ethminerAMDPaused = toStop;
                            }
                        }
                    }

                    // start new miners
                    foreach (var toStart in toRunNewGroupMiners.Values)
                    {
                        stringBuilderCurrentAlgo.Append(String.Format("{0}: {1}, ", toStart.DevicesInfoString, toStart.AlgorithmType));

                        toStart.Start(_miningLocation, _btcAdress, _worker);
                        _runningGroupMiners[toStart.Key] = toStart;
                    }

                    // which miners dosen't change
                    foreach (var noChange in noChangeGroupMiners.Values)
                    {
                        stringBuilderNoChangeAlgo.Append(String.Format("{0}: {1}, ", noChange.DevicesInfoString, noChange.AlgorithmType));
                    }

                    if (stringBuilderPreviousAlgo.Length > 0)
                    {
                        Helpers.ConsolePrint(TAG, String.Format("Stop Mining: {0}", stringBuilderPreviousAlgo.ToString()));
                    }

                    if (stringBuilderCurrentAlgo.Length > 0)
                    {
                        Helpers.ConsolePrint(TAG, String.Format("Now Mining : {0}", stringBuilderCurrentAlgo.ToString()));
                    }

                    if (stringBuilderNoChangeAlgo.Length > 0)
                    {
                        Helpers.ConsolePrint(TAG, String.Format("No change  : {0}", stringBuilderNoChangeAlgo.ToString()));
                    }
                }
            }

            // stats quick fix code
            //if (_currentAllGroupedDevices.Count != _previousAllGroupedDevices.Count) {
            await MinerStatsCheck(NiceHashData);

            //}
        }
        public async Task SwichMostProfitableGroupUpMethod(Dictionary <AlgorithmType, CryptoMiner937API> CryptoMiner937Data, bool log = false)
        {
#if (SWITCH_TESTING)
            MiningDevice.SetNextTest();
#endif
            List <MiningPair> profitableDevices = new List <MiningPair>();
            double            CurrentProfit     = 0.0d;
            double            PrevStateProfit   = 0.0d;
            foreach (var device in _miningDevices)
            {
                // calculate profits
                device.CalculateProfits(CryptoMiner937Data);
                // check if device has profitable algo
                if (device.HasProfitableAlgo())
                {
                    profitableDevices.Add(device.GetMostProfitablePair());
                    CurrentProfit   += device.GetCurrentMostProfitValue;
                    PrevStateProfit += device.GetPrevMostProfitValue;
                }
            }

            // print profit statuses
            if (log)
            {
                StringBuilder stringBuilderFull = new StringBuilder();
                stringBuilderFull.AppendLine("Current device profits:");
                foreach (var device in _miningDevices)
                {
                    StringBuilder stringBuilderDevice = new StringBuilder();
                    stringBuilderDevice.AppendLine(String.Format("\tProfits for {0} ({1}):", device.Device.UUID, device.Device.GetFullName()));
                    foreach (var algo in device.Algorithms)
                    {
                        stringBuilderDevice.AppendLine(String.Format("\t\tPROFIT = {0}\t(SPEED = {1}\t\t| NHSMA = {2})\t[{3}]",
                                                                     algo.CurrentProfit.ToString(DOUBLE_FORMAT),                                          // Profit
                                                                     algo.AvaragedSpeed + (algo.IsDual() ? "/" + algo.SecondaryAveragedSpeed : ""),       // Speed
                                                                     algo.CurNhmSMADataVal + (algo.IsDual() ? "/" + algo.SecondaryCurNhmSMADataVal : ""), // CryptoMiner937Data
                                                                     algo.AlgorithmStringID                                                               // Name
                                                                     ));
                    }
                    // most profitable
                    stringBuilderDevice.AppendLine(String.Format("\t\tMOST PROFITABLE ALGO: {0}, PROFIT: {1}",
                                                                 device.GetMostProfitableString(),
                                                                 device.GetCurrentMostProfitValue.ToString(DOUBLE_FORMAT)));
                    stringBuilderFull.AppendLine(stringBuilderDevice.ToString());
                }
                Helpers.ConsolePrint(TAG, stringBuilderFull.ToString());
            }

            // check if should mine
            // Only check if profitable inside this method when getting SMA data, cheching during mining is not reliable
            if (CheckIfShouldMine(CurrentProfit, log) == false)
            {
                foreach (var device in _miningDevices)
                {
                    device.SetNotMining();
                }
                return;
            }

            // check profit threshold
            Helpers.ConsolePrint(TAG, String.Format("PrevStateProfit {0}, CurrentProfit {1}", PrevStateProfit, CurrentProfit));
            if (PrevStateProfit > 0 && CurrentProfit > 0)
            {
                double a = Math.Max(PrevStateProfit, CurrentProfit);
                double b = Math.Min(PrevStateProfit, CurrentProfit);
                //double percDiff = Math.Abs((PrevStateProfit / CurrentProfit) - 1);
                double percDiff = ((a - b)) / b;
                if (percDiff < ConfigManager.GeneralConfig.SwitchProfitabilityThreshold)
                {
                    // don't switch
                    //Helpers.ConsolePrint(TAG, String.Format("Will NOT switch profit diff is {0}, current threshold {1}", percDiff, ConfigManager.GeneralConfig.SwitchProfitabilityThreshold));
                    // RESTORE OLD PROFITS STATE
                    foreach (var device in _miningDevices)
                    {
                        device.RestoreOldProfitsState();
                    }
                    if (!SHOULD_START_DONATING)
                    {
                        return;
                    }
                }
                else
                {
                    Helpers.ConsolePrint(TAG, String.Format("Will SWITCH profit diff is {0}, current threshold {1}", percDiff, ConfigManager.GeneralConfig.SwitchProfitabilityThreshold));
                }
            }

            Helpers.ConsolePrint("Monitoring", "If enabled here I would submit Monitoring data to the server");

            if (ConfigManager.GeneralConfig.monitoring == true)
            {                  //Run monitoring command here
                var monversion = "Hash-Kings Miner V" + Application.ProductVersion;
#pragma warning disable CS0219 // The variable 'monstatus' is assigned but its value is never used
                var monstatus = "Running";
#pragma warning restore CS0219 // The variable 'monstatus' is assigned but its value is never used
#pragma warning disable CS0219 // The variable 'monrunningminers' is assigned but its value is never used
                var monrunningminers = "" /*Runningminers go here*/;
#pragma warning restore CS0219 // The variable 'monrunningminers' is assigned but its value is never used
                var monserver = ConfigManager.GeneralConfig.MonServerurl + "/api/report.php";
                var request   = (HttpWebRequest)WebRequest.Create(monserver);
                var postData  = "";

                /* fetch last command line for each miner
                 * Do this for each mining group*/
                foreach (var cdev in ComputeDeviceManager.Avaliable.AllAvaliableDevices)
                {
                    if (cdev.Enabled)
                    {
                        postData += "Name" + Uri.EscapeDataString("Miner Name");
                        postData += "Path" + Uri.EscapeDataString("miner Path goes here");
                        postData += "Type" + Uri.EscapeDataString("Type of card EX. AMD");
                        postData += "Algorithm" + Uri.EscapeDataString("Current mining Algorithm");
                        postData += "Pool" + Uri.EscapeDataString("Pool Goes Here");
                        postData += "CurrentSpeed" + Uri.EscapeDataString("Actual hashrate goes here");
                        postData += "EstimatedSpeed" + Uri.EscapeDataString("Benchmark hashrate Goes Here");
                        postData += "Profit" + Uri.EscapeDataString("group profitability goes here");
                    }
                    ;
                }

                /*
                 *
                 * Convert above data to Json
                 * Fetch Profit to Variable
                 * $Profit = [string]([Math]::Round(($data | Measure-Object Profit -Sum).Sum, 8))
                 * Send the request
                 * $Body = @{user = $Config.MonitoringUser; worker = $Config.WorkerName; version = $Version; status = $Status; profit = $Profit; data = $DataJSON}
                 * Try {
                 * $Response = Invoke-RestMethod -Uri "$($Config.MonitoringServer)/api/report.php" -Method Post -Body $Body -UseBasicParsing -TimeoutSec 10 -ErrorAction Stop
                 * Helpers.ConsolePrint("Monitoring", "Reporting status to server..." + $Server responce here"
                 * }
                 * Catch {
                 * Helpers.ConsolePrint("Monitoring", "Unable to send status to " monserver}*/
                var data = Encoding.ASCII.GetBytes(postData);
                request.Method        = "POST";
                request.ContentType   = "application/x-www-form-urlencoded";
                request.ContentLength = data.Length;

                using (var stream = request.GetRequestStream())
                {
                    stream.Write(data, 0, data.Length);
                }

                var response = (HttpWebResponse)request.GetResponse();

                var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();
            }



            // group new miners
            Dictionary <string, List <MiningPair> > newGroupedMiningPairs = new Dictionary <string, List <MiningPair> >();
            // group devices with same supported algorithms
            {
                var currentGroupedDevices = new List <GroupedDevices>();
                for (int first = 0; first < profitableDevices.Count; ++first)
                {
                    var firstDev = profitableDevices[first].Device;
                    // check if is in group
                    bool isInGroup = false;
                    foreach (var groupedDevices in currentGroupedDevices)
                    {
                        if (groupedDevices.Contains(firstDev.UUID))
                        {
                            isInGroup = true;
                            break;
                        }
                    }
                    // if device is not in any group create new group and check if other device should group
                    if (isInGroup == false)
                    {
                        var newGroup    = new GroupedDevices();
                        var miningPairs = new List <MiningPair>()
                        {
                            profitableDevices[first]
                        };
                        newGroup.Add(firstDev.UUID);
                        for (int second = first + 1; second < profitableDevices.Count; ++second)
                        {
                            // check if we should group
                            var firstPair  = profitableDevices[first];
                            var secondPair = profitableDevices[second];
                            if (GroupingLogic.ShouldGroup(firstPair, secondPair))
                            {
                                var secondDev = profitableDevices[second].Device;
                                newGroup.Add(secondDev.UUID);
                                miningPairs.Add(profitableDevices[second]);
                            }
                        }
                        currentGroupedDevices.Add(newGroup);
                        newGroupedMiningPairs[CalcGroupedDevicesKey(newGroup)] = miningPairs;
                    }
                }
            }
            //bool IsMinerStatsCheckUpdate = false;
            {
                // check which groupMiners should be stopped and which ones should be started and which to keep running
                Dictionary <string, GroupMiner> toStopGroupMiners   = new Dictionary <string, GroupMiner>();
                Dictionary <string, GroupMiner> toRunNewGroupMiners = new Dictionary <string, GroupMiner>();
                Dictionary <string, GroupMiner> noChangeGroupMiners = new Dictionary <string, GroupMiner>();
                if (MiningSession.SHOULD_START_DONATING)
                {
                    MiningSession.IS_DONATING = true;
                }

                // check what to stop/update
                int count = _runningGroupMiners.Keys.Count;
                int it    = 0;
                //  + " Mining For : " +(MiningSession.DONATION_SESSION ? "Developer" : "User")
                foreach (string runningGroupKey in _runningGroupMiners.Keys)
                {
                    it++;
                    if (newGroupedMiningPairs.ContainsKey(runningGroupKey) == false)
                    {
                        // runningGroupKey not in new group definately needs to be stopped and removed from curently running
                        toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey];
                    }
                    // If we need to start donating, stop everything
                    else if (MiningSession.IS_DONATING && !MiningSession.DONATION_SESSION)
                    {
                        if (it == count)
                        {
                            MiningSession.DONATION_SESSION = true;
                        }
                        toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey];

                        Helpers.ConsolePrint(TAG, "STARTING - DEV_FEE - Mining Dev-Fee for 24 Minutes.");
                        var        miningPairs   = newGroupedMiningPairs[runningGroupKey];
                        var        newAlgoType   = GetMinerPairAlgorithmType(miningPairs);
                        GroupMiner newGroupMiner = null;
                        if (newAlgoType == AlgorithmType.DaggerHashimoto)
                        {
                            if (_ethminerNVIDIAPaused != null && _ethminerNVIDIAPaused.Key == runningGroupKey)
                            {
                                newGroupMiner = _ethminerNVIDIAPaused;
                            }
                            if (_ethminerAMDPaused != null && _ethminerAMDPaused.Key == runningGroupKey)
                            {
                                newGroupMiner = _ethminerAMDPaused;
                            }
                        }
                        if (newGroupMiner == null)
                        {
                            newGroupMiner = new GroupMiner(miningPairs, runningGroupKey);
                        }
                        toRunNewGroupMiners[runningGroupKey] = newGroupMiner;
                    }
                    else if (MiningSession.IS_DONATING && MiningSession.DONATION_SESSION && MiningSession.SHOULD_STOP_DONATING)
                    {
                        if (it == count)
                        {
                            MiningSession.DONATION_SESSION = false;
                            MiningSession.IS_DONATING      = false;
                            MiningSession.DonationStart    = MiningSession.DonationStart.Add(MiningSession.DonateEvery);
                        }
                        toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey];
                        Helpers.ConsolePrint(TAG, "STOPPING - DEV_FEE - Next Dev-Fee Mining will start in 24 Hours.");
                        var        miningPairs   = newGroupedMiningPairs[runningGroupKey];
                        var        newAlgoType   = GetMinerPairAlgorithmType(miningPairs);
                        GroupMiner newGroupMiner = null;
                        if (newAlgoType == AlgorithmType.DaggerHashimoto)
                        {
                            if (_ethminerNVIDIAPaused != null && _ethminerNVIDIAPaused.Key == runningGroupKey)
                            {
                                newGroupMiner = _ethminerNVIDIAPaused;
                            }
                            if (_ethminerAMDPaused != null && _ethminerAMDPaused.Key == runningGroupKey)
                            {
                                newGroupMiner = _ethminerAMDPaused;
                            }
                        }
                        if (newGroupMiner == null)
                        {
                            newGroupMiner = new GroupMiner(miningPairs, runningGroupKey);
                        }
                        toRunNewGroupMiners[runningGroupKey] = newGroupMiner;
                    }
                    else
                    {
                        MiningSession.DONATION_SESSION = false;
                        MiningSession.IS_DONATING      = false;
                        // runningGroupKey is contained but needs to check if mining algorithm is changed
                        var miningPairs = newGroupedMiningPairs[runningGroupKey];
                        var newAlgoType = GetMinerPairAlgorithmType(miningPairs);
                        if (newAlgoType != AlgorithmType.NONE && newAlgoType != AlgorithmType.INVALID)
                        {
                            // if algoType valid and different from currently running update
                            if (newAlgoType != _runningGroupMiners[runningGroupKey].DualAlgorithmType)
                            {
                                // remove current one and schedule to stop mining
                                toStopGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey];
                                // create new one TODO check if DaggerHashimoto
                                GroupMiner newGroupMiner = null;
                                if (newAlgoType == AlgorithmType.DaggerHashimoto)
                                {
                                    if (_ethminerNVIDIAPaused != null && _ethminerNVIDIAPaused.Key == runningGroupKey)
                                    {
                                        newGroupMiner = _ethminerNVIDIAPaused;
                                    }
                                    if (_ethminerAMDPaused != null && _ethminerAMDPaused.Key == runningGroupKey)
                                    {
                                        newGroupMiner = _ethminerAMDPaused;
                                    }
                                }
                                if (newGroupMiner == null)
                                {
                                    newGroupMiner = new GroupMiner(miningPairs, runningGroupKey);
                                }
                                toRunNewGroupMiners[runningGroupKey] = newGroupMiner;
                            }
                            else
                            {
                                noChangeGroupMiners[runningGroupKey] = _runningGroupMiners[runningGroupKey];
                            }
                        }
                    }
                }
                // check brand new
                foreach (var kvp in newGroupedMiningPairs)
                {
                    var key         = kvp.Key;
                    var miningPairs = kvp.Value;
                    if (_runningGroupMiners.ContainsKey(key) == false)
                    {
                        GroupMiner newGroupMiner = new GroupMiner(miningPairs, key);
                        toRunNewGroupMiners[key] = newGroupMiner;
                    }
                }

                if ((toStopGroupMiners.Values.Count > 0) || (toRunNewGroupMiners.Values.Count > 0))
                {
                    StringBuilder stringBuilderPreviousAlgo = new StringBuilder();
                    StringBuilder stringBuilderCurrentAlgo  = new StringBuilder();
                    StringBuilder stringBuilderNoChangeAlgo = new StringBuilder();
                    // stop old miners
                    foreach (var toStop in toStopGroupMiners.Values)
                    {
                        stringBuilderPreviousAlgo.Append(String.Format("{0}: {1}, ", toStop.DevicesInfoString, toStop.AlgorithmType));

                        toStop.Stop();
                        _runningGroupMiners.Remove(toStop.Key);
                        // TODO check if daggerHashimoto and save
                        if (toStop.AlgorithmType == AlgorithmType.DaggerHashimoto)
                        {
                            if (toStop.DeviceType == DeviceType.NVIDIA)
                            {
                                _ethminerNVIDIAPaused = toStop;
                            }
                            else if (toStop.DeviceType == DeviceType.AMD)
                            {
                                _ethminerAMDPaused = toStop;
                            }
                        }
                    }

                    // start new miners
                    foreach (var toStart in toRunNewGroupMiners.Values)
                    {
                        stringBuilderCurrentAlgo.Append(String.Format("{0}: {1}, ", toStart.DevicesInfoString, toStart.AlgorithmType));

                        toStart.Start(_miningLocation, _btcAddress, _worker);
                        _runningGroupMiners[toStart.Key] = toStart;
                    }

                    // which miners dosen't change
                    foreach (var noChange in noChangeGroupMiners.Values)
                    {
                        stringBuilderNoChangeAlgo.Append(String.Format("{0}: {1}, ", noChange.DevicesInfoString, noChange.AlgorithmType));
                    }

                    if (stringBuilderPreviousAlgo.Length > 0)
                    {
                        Helpers.ConsolePrint(TAG, String.Format("Stop Mining: {0}", stringBuilderPreviousAlgo.ToString()));
                    }

                    if (stringBuilderCurrentAlgo.Length > 0)
                    {
                        Helpers.ConsolePrint(TAG, String.Format("Now Mining : {0}", stringBuilderCurrentAlgo.ToString()));
                    }

                    if (stringBuilderNoChangeAlgo.Length > 0)
                    {
                        Helpers.ConsolePrint(TAG, String.Format("No change  : {0}", stringBuilderNoChangeAlgo.ToString()));
                    }
                }
            }

            // stats quick fix code
            //if (_currentAllGroupedDevices.Count != _previousAllGroupedDevices.Count) {
            await MinerStatsCheck(CryptoMiner937Data);

            //}
        }