Пример #1
0
        public void StopMiner()
        {
            if (!_process.IsRunning())
            {
                _process = null;
                return;
            }

            LogActivity(_donationMiningMode == MiningModeEnum.Donation ? "DonationStop" : "Stop");
            WriteConsole(string.Format("Stopping {0} {1}", _currentRunning.ServicePrint, _currentRunning.AlgoName), true);
            RecordMiningTime();
            if (MinerKillMode == 0)
            {
                ProcessUtil.KillProcess(_process);
            }
            else
            {
                ProcessUtil.KillProcessAndChildren(_process.Id);
            }

            _process            = null;
            _donationMiningMode = MiningModeEnum.Stopped;

            if (_currentRunning != null)
            {
                PriceEntryBase entry = PriceEntries.Single(o => o.Id == _currentRunning.Id);
                entry.UpdateStatus();
            }

            if (_stoppedMining == null)
            {
                _stoppedMining = DateTime.Now;
            }
            _currentRunning = null;
        }
Пример #2
0
        private void dgPrices_CellMouseClick(object sender, DataGridViewCellMouseEventArgs e)
        {
            DataGridView senderGrid = (DataGridView)sender;

            if (senderGrid.Columns[e.ColumnIndex] is DataGridViewCheckBoxColumn && e.RowIndex >= 0)
            {
                IList <PriceEntryBase> data  = senderGrid.DataSource as IList <PriceEntryBase>;
                PriceEntryBase         entry = data[e.RowIndex];

                switch ((bool)dgPrices.CurrentCell.FormattedValue)
                {
                case true:
                    dgPrices.CurrentCell.Value = "false";
                    entry.Enabled = false;
                    // entry.Banned = true;
                    dgPrices.CurrentRow.DefaultCellStyle.ForeColor = Color.DarkGray;
                    break;

                case false:
                    dgPrices.CurrentCell.Value = "true";
                    entry.Enabled = true;
                    // entry.Banned = false;
                    dgPrices.CurrentRow.DefaultCellStyle.ForeColor = Color.Black;
                    break;
                }
                UpdateGrid();
            }
        }
Пример #3
0
        public void RequestStart(ServiceEnum service, string algo, bool isMinimizedToTray)
        {
            PriceEntryBase entry = null;

            foreach (PriceEntryBase priceEntry in _priceEntries)
            {
                if (priceEntry.AlgoName == algo)
                {
                    entry = priceEntry;
                    if (priceEntry.ServiceEntry.ServiceEnum == service)
                    {
                        break;
                    }
                }
            }

            if (entry == null)
            {
                RunBestAlgo(isMinimizedToTray);
            }
            else
            {
                StartMiner(entry, isMinimizedToTray);
            }
        }
Пример #4
0
        private void CheckBoxUpdate()
        {
            int _stActive = 1;

            if (dgPrices.Columns.Contains("Active"))
            {
                _stActive = dgPrices.Columns.IndexOf(dgPrices.Columns["Active"]);
            }

            foreach (DataGridViewRow row in dgPrices.Rows)
            {
                IList <PriceEntryBase> data  = dgPrices.DataSource as IList <PriceEntryBase>;
                PriceEntryBase         entry = data[row.Index];

                if (entry.Enabled == true)
                {
                    row.Cells[_stActive].Value = "true";
                }
                else
                {
                    row.Cells[_stActive].Value     = "false";
                    row.DefaultCellStyle.ForeColor = Color.DarkGray;
                }
            }
        }
Пример #5
0
        public void GetPrices(float price, float er, float price24, float er24, string cname, bool _lagstatus)
        {
            float ep = 0; float ex = 0;

            switch (_pricemode)
            {
            case 1:
                ep = price24; ex = er24;
                break;

            default:
                ep = price; ex = er;
                break;
            }

            PriceEntryBase entry = GetEntryCoin(cname.ToString().ToLower());

            if (entry == null)
            {
                entry = GetEntryCoin(WTMTranslation(cname.ToLower()).ToString().ToLower());
            }

            if (entry != null)
            {
                lock (MiningEngine)
                {
                    {
                        entry.Price  = (decimal)ep * 1000000000;
                        entry.ExRate = (decimal)ex;


                        PriceDynamics(price, er, price24, er24, entry);
                        //AveragePrice(entry);

                        entry.Lagging = _lagstatus;

                        if (MiningEngine._pumpreduction == true && entry.Pumping == true)
                        {
                            entry.Price         = entry.Price / ((decimal)(entry.AvgExRate / er24) - MiningEngine._dynoffset / 100);
                            entry.PumpReduction = true;
                        }
                        else
                        {
                            entry.PumpReduction = false;
                        }

                        entry.DynUpdated = DateTime.Now;
                    }

                    MiningEngine.PricesUpdated = true;
                    MiningEngine.HasPrices     = true;

                    LastUpdated = DateTime.Now;

                    UpdateHistory();
                }
            }
        }
Пример #6
0
        private string ActiveTime(PriceEntryBase priceEntry)
        {
            TimeSpan time = priceEntry.TimeMining;

            if (_engine.CurrentRunning == priceEntry.Id && _engine.StartMining.HasValue)
            {
                time += (DateTime.Now - _engine.StartMining.Value);
            }
            return(time.FormatTime());
        }
Пример #7
0
        private void dgPrices_CellMouseDoubleClick(object sender, DataGridViewCellMouseEventArgs e)
        {
            DataGridView senderGrid = (DataGridView)sender;

            if (e.RowIndex >= 0)
            {
                IList <PriceEntryBase> data  = senderGrid.DataSource as IList <PriceEntryBase>;
                PriceEntryBase         entry = data[e.RowIndex];

                _engine.SwitchBanStatus(entry.ServicePrint);
                UpdateGrid();
            }
        }
Пример #8
0
        private string DetectNiceHashStratum(PriceEntryBase entry)
        {
            if (entry.ServiceEntry.ServiceName != "NiceHash" && entry.ServiceEntry.ServiceName != "WestHash")
            {
                return(string.Empty);
            }
            NiceHashService niceHash = entry.ServiceEntry as NiceHashService;

            if (niceHash == null || niceHash.DetectStratum == false)
            {
                return(string.Empty);
            }

            return("-o stratum+tcp://" + niceHash.GetBestStratum(entry.AlgoName) + " ");
        }
Пример #9
0
        private void MPOSFee(object RawData)
        {
            if (RawData != null)
            {
                JObject data = (JObject)RawData;
                JToken  gpi  = data["getpoolinfo"];
                JToken  dat  = gpi["data"];
                JToken  tag  = dat["currency"];
                JToken  fee  = (float)dat["fees"];

                PriceEntryBase entry = GetEntryTag(tag.ToString().ToLower());
                if (entry != null)
                {
                    entry.FeePercent = 1 - (1 - (decimal)fee / 100) * (1 - _BtcFee / 100);
                }
            }
        }
Пример #10
0
        private void MPOSBalances(object RawData)
        {
            if (RawData != null)
            {
                JObject data      = (JObject)RawData;
                JToken  gub       = data["getuserbalance"];
                JToken  bal       = gub["data"];
                float   confirmed = (float)bal["confirmed"];
                float   unpaid    = (float)bal["unconfirmed"];
                JToken  status    = data["getuserbalance"]["version"];

                PriceEntryBase entry = GetEntryCoin(status.ToString().ToLower());
                if (entry != null)
                {
                    entry.Balance    = confirmed.ExtractDecimal();
                    entry.Pending    = unpaid.ExtractDecimal();
                    entry.BalanceBTC = confirmed.ExtractDecimal() * entry.ExRate;
                }
            }
        }
Пример #11
0
        private void dgPrices_CellContentClick(object sender, DataGridViewCellEventArgs e)
        {
            if (_engine.MiningMode != MiningModeEnum.Stopped)
            {
                return;
            }

            DataGridView senderGrid = (DataGridView)sender;

            if (senderGrid.Columns[e.ColumnIndex] is DataGridViewButtonColumn && e.RowIndex >= 0)
            {
                IList <PriceEntryBase> data  = senderGrid.DataSource as IList <PriceEntryBase>;
                PriceEntryBase         entry = data[e.RowIndex];

                _engine.MiningMode = MiningModeEnum.Manual;
                UpdateButtons();
                _engine.RequestStart(entry.Id, IsMinimizedToTray);
                UpdateGrid();
            }
        }
Пример #12
0
        private void APIProcessData(object RawData)
        {
            if (RawData != null)
            {
                float bal = 0; float pend = 0; float hashrate = 0;

                JObject data = (JObject)RawData;
                bal  = (float)data["confirmed_rewards"];
                pend = (float)data["round_estimate"];
                string cname = data["username"].ToString();
                hashrate = (float)data["total_hashrate"];
                JToken workers = data["workers"];

                PriceEntryBase entry = GetEntryCoin(cname.ToString());
                if (entry != null)
                {
                    entry.Balance    = bal.ExtractDecimal();
                    entry.Pending    = pend.ExtractDecimal();
                    entry.BalanceBTC = entry.Balance * entry.ExRate;

                    if (_nospeed == false)
                    {
                        entry.AcceptSpeed = hashrate.ExtractDecimal();
                    }

                    if (_nospeedworker == false && workers != null)
                    {
                        foreach (JProperty item in workers.Children())
                        {
                            var s = (float)item.Value["hashrate"];
                            if (item.Name.ToString().ToLower() == _account.ToString().ToLower() + "." + _worker.ToString().ToLower() && s > 0)
                            {
                                entry.AcSpWrk = s.ExtractDecimal();

                                AverageSpeed(entry);
                            }
                        }
                    }
                }
            }
        }
Пример #13
0
        public void ReadData(IDictionary <string, object> data)
        {
            ExtractCommon(data);


            object[] items = data["algos"] as object[];
            foreach (object rawitem in items)
            {
                Dictionary <string, object> item = rawitem as Dictionary <string, object>;
                PriceEntryBase entry             = CreateEntry(item);

                if (!MiningEngine._showinactive && !entry.Enabled)
                {
                    continue;
                }
                else
                {
                    MiningEngine.PriceEntries.Add(entry);
                }
            }
        }
Пример #14
0
        public void UpdatePrice(PriceEntryBase priceEntryBase)
        {
            DateTime now   = DateTime.Now;
            decimal  price = priceEntryBase.NetEarn;

            decimal totalPrice = price;
            int     totalCount = PriceList.Count;

            List <decimal> window = new List <decimal> {
                price
            };
            decimal windowedPrice = price;
            int     windowedCount = 0;
            bool    outlier       = false;

            if (!PriceList.ContainsKey(priceEntryBase))
            {
                PriceList.Add(priceEntryBase, new List <PriceStat>());
            }

            foreach (PriceStat stat in PriceList[priceEntryBase])
            {
                if (stat.CurrentPrice > 0)
                {
                    decimal historicPrice = stat.CurrentPrice;
                    totalPrice += historicPrice;

                    if (stat.Time == now)
                    {
                        return;
                    }
                    if (stat.Time >= now - _statWindow)
                    {
                        window.Add(historicPrice);
                        windowedPrice += historicPrice;
                        windowedCount++;
                    }
                }
            }

            decimal totalAveragePrice    = totalPrice / (totalCount + 1);
            decimal windowedAveragePrice = windowedPrice / (windowedCount + 1);

            if (windowedCount >= 10) // Makes sure at least ten entries are in there
            {
                window.Sort();
                if (_iqrMultiplier > 0)
                {
                    double sumOfSquareOfDifferences =
                        (double)PriceList[priceEntryBase].Where(stat => stat.Time >= now - _statWindow)
                        .Sum(stat =>
                             (stat.CurrentPrice - windowedAveragePrice) *
                             (stat.CurrentPrice - windowedAveragePrice));
                    decimal standardDeviation = (decimal)Math.Sqrt(sumOfSquareOfDifferences / windowedCount);
                    decimal top    = windowedAveragePrice + standardDeviation;
                    decimal bottom = windowedAveragePrice - standardDeviation;
                    decimal iqr    = top - bottom;
                    decimal max    = windowedAveragePrice + (iqr * _iqrMultiplier);
                    outlier = price > max;
                }
                else
                {
                    // If the IQR multiplier is negative or zero,
                    // it'll try to use percentiles for outlierdetection
                    // Not advised! Will kill off trending profits, iqr-multiplying is preferable
                    int       outlierIndex = (int)Math.Truncate(window.Count * _percentile);
                    decimal[] outliers     = { window[outlierIndex], window[window.Count - outlierIndex] };
                    outlier = price > outliers.Max();
                }
            }


            PriceStat priceStat = new PriceStat
            {
                Time                 = now,
                CurrentPrice         = price,
                TotalAveragePrice    = totalAveragePrice,
                WindowedAveragePrice = windowedAveragePrice,
                Outlier              = outlier
            };

            priceEntryBase.Outlier    = outlier;
            priceEntryBase.NetAverage = windowedAveragePrice;

            // if (priceEntryBase.Enabled == true)
            PriceList[priceEntryBase].Add(priceStat);
        }
Пример #15
0
        private void StartMiner(PriceEntryBase entry, bool isMinimizedToTray = false)
        {
            _nextRun         = null;
            _nextRunFromTime = null;
            _currentRunning  = entry;
            _startMining     = DateTime.Now;

            _process = new Process();
            if (_donationMiningMode == MiningModeEnum.Donation)
            {
                if (!string.IsNullOrWhiteSpace(entry.DonationFolder))
                {
                    _process.StartInfo.WorkingDirectory = entry.DonationFolder;
                }
                _process.StartInfo.FileName = string.IsNullOrWhiteSpace(entry.DonationFolder)
                    ? entry.DonationCommand
                    : string.Format(@"{0}\{1}", entry.DonationFolder, entry.DonationCommand);
                _process.StartInfo.Arguments = entry.DonationArguments;
            }
            else
            {
                if (!string.IsNullOrWhiteSpace(entry.Folder))
                {
                    _process.StartInfo.WorkingDirectory = entry.Folder;
                }
                _process.StartInfo.FileName = string.IsNullOrWhiteSpace(entry.Folder)
                    ? entry.Command
                    : string.Format(@"{0}\{1}", entry.Folder, entry.Command);
                _process.StartInfo.Arguments = entry.Arguments;
            }

            WriteConsole(string.Format("Starting {0} {1} with {2} {3}", _currentRunning.ServicePrint, _currentRunning.Name, _process.StartInfo.FileName, _process.StartInfo.Arguments), true);

            if (!string.IsNullOrWhiteSpace(_process.StartInfo.WorkingDirectory) && !Directory.Exists(_process.StartInfo.WorkingDirectory))
            {
                entry.DeadTime = DateTime.Now;
                var message = string.Format("Path '{0}' does not exist.", _process.StartInfo.WorkingDirectory);
                _process = null;
                WriteConsole(message, true);
                throw new ArgumentException(message);
            }
            if (!string.IsNullOrWhiteSpace(_process.StartInfo.FileName) && !File.Exists(_process.StartInfo.FileName))
            {
                entry.DeadTime = DateTime.Now;
                var message = string.Format("File '{0}' does not exist.", _process.StartInfo.FileName);
                _process = null;
                WriteConsole(message, true);
                throw new ArgumentException(message);
            }

            if (entry.UseWindow)
            {
                _process.StartInfo.WindowStyle = (isMinimizedToTray && TrayMode == 2) ? ProcessWindowStyle.Hidden : ProcessWindowStyle.Minimized;
                _process.Start();

                Thread.Sleep(100);
                try
                {
                    ProcessUtil.SetWindowTitle(_process, string.Format("{0} {1} Miner", entry.ServicePrint, entry.Name));
                }
                catch (Exception ex)
                {
                    ErrorLogger.Log(ex);
                }

                if (isMinimizedToTray && TrayMode == 1)
                {
                    HideMinerWindow();
                }
            }
            else
            {
                _process.StartInfo.RedirectStandardOutput = true;
                _process.StartInfo.RedirectStandardError  = true;
                _process.EnableRaisingEvents       = true;
                _process.StartInfo.CreateNoWindow  = true;
                _process.StartInfo.UseShellExecute = false;

                _process.ErrorDataReceived  += ProcessConsoleOutput;
                _process.OutputDataReceived += ProcessConsoleOutput;

                _process.Start();

                _process.BeginOutputReadLine();
                _process.BeginErrorReadLine();
            }

            _startMining        = DateTime.Now;
            _donationMiningMode = MiningMode;

            entry.UpdateStatus();

            LogActivity(_donationMiningMode == MiningModeEnum.Donation ? "DonationStart" : "Start");
        }
Пример #16
0
        public void RunBestAlgo(bool isMinimizedToTray)
        {
            try
            {
                // Check for dead process
                if (!_process.IsRunning() && _currentRunning != null)
                {
                    lock (this)
                    {
                        _currentRunning.DeadTime = DateTime.Now;
                        LogActivity(_donationMiningMode == MiningModeEnum.Donation ? "DonationDead" : "Dead");
                        WriteConsole(string.Format("Dead {0} {1}", _currentRunning.ServicePrint, _currentRunning.Name), true);
                        RecordMiningTime();
                    }
                }

                // Clear information if process not running
                if (_process == null || _process.HasExited)
                {
                    _currentRunning  = null;
                    _startMining     = null;
                    _nextRun         = null;
                    _nextRunFromTime = null;
                }

                // Donation mining
                if (DoDonationMinging)
                {
                    if (_donationMiningMode == MiningModeEnum.Automatic && TimeUntilDonation == TimeSpan.Zero)
                    {
                        StopMiner();
                        _donationMiningMode = MiningModeEnum.Donation;
                        MiningMode          = _donationMiningMode;
                        _autoMiningTime     = TimeSpan.Zero;
                    }
                    else if (_donationMiningMode == MiningModeEnum.Donation && TimeDuringDonation == TimeSpan.Zero)
                    {
                        StopMiner();
                        _donationMiningMode = MiningModeEnum.Automatic;
                        MiningMode          = _donationMiningMode;
                        _donationMiningTime = TimeSpan.Zero;
                    }
                }

                // Restart miner if max time reached
                if (RestartTime.HasValue && RestartTime.Value <= TimeSpan.Zero)
                {
                    StopMiner();
                }

                // Find the best, live entry
                var best = _donationMiningMode == MiningModeEnum.Donation
                    ? _priceEntries
                           .Where(o => !o.IsDead)
                           .Where(o => !string.IsNullOrWhiteSpace(o.DonationCommand))
                           .OrderByDescending(o => o.NetEarn)
                           .First()
                    : _priceEntries
                           .Where(o => !o.IsDead)
                           .Where(o => !string.IsNullOrWhiteSpace(o.Command))
                           .OrderByDescending(o => o.NetEarn)
                           .First();

                // Handle minimum time for better algorithm before switching
                if (_switchTime > TimeSpan.Zero && _currentRunning != null)
                {
                    if (!_nextRun.HasValue && _currentRunning.Id != best.Id)
                    {
                        _nextRun         = best.Id;
                        _nextRunFromTime = DateTime.Now;
                    }
                    else if (_nextRun.HasValue && _currentRunning.Id == best.Id)
                    {
                        _nextRun         = null;
                        _nextRunFromTime = null;
                    }
                    if (NextRunTime.HasValue && NextRunTime > TimeSpan.Zero)
                    {
                        best = _priceEntries.First(o => o.Id == _currentRunning.Id);
                    }
                }

                // Update undead entries
                var entries = PriceEntries.Where(o => !o.IsDead && o.DeadTime != DateTime.MinValue);
                foreach (var entry in entries)
                {
                    entry.DeadTime = DateTime.MinValue;
                }

                // Just update time if we are already running the right entry
                if (_currentRunning != null && _currentRunning.Id == best.Id)
                {
                    _currentRunning.UpdateStatus();
                    return;
                }

                // Honor minimum time to run in auto mode
                if (MiningTime.HasValue && MiningTime.Value < _minTime)
                {
                    _currentRunning.UpdateStatus();
                    return;
                }

                StopMiner();
                StartMiner(best, isMinimizedToTray);
            }
            catch (Exception ex)
            {
                ErrorLogger.Log(ex);
            }
        }
Пример #17
0
        public void RunBestAlgo(bool isMinimizedToTray)
        {
            try
            {
                // Check for dead process
                if (!_process.IsRunning() && _currentRunning != null)
                {
                    lock (this)
                    {
                        _currentRunning.DeadTime = DateTime.Now;
                        LogActivity(_donationMiningMode == MiningModeEnum.Donation ? "DonationDead" : "Dead");
                        WriteConsole(string.Format("Dead {0} {1}", _currentRunning.ServicePrint, _currentRunning.Name),
                                     true);
                        RecordMiningTime();
                    }
                }

                // Clear information if process not running
                if (!_process.IsRunning())
                {
                    _currentRunning  = null;
                    _startMining     = null;
                    _nextRun         = null;
                    _nextRunFromTime = null;
                }

                // Donation mining
                if (DoDonationMinging)
                {
                    if (_donationMiningMode == MiningModeEnum.Automatic && TimeUntilDonation == TimeSpan.Zero)
                    {
                        StopMiner();
                        _donationMiningMode = MiningModeEnum.Donation;
                        MiningMode          = _donationMiningMode;
                        _autoMiningTime     = TimeSpan.Zero;
                    }
                    else if (_donationMiningMode == MiningModeEnum.Donation && TimeDuringDonation == TimeSpan.Zero)
                    {
                        StopMiner();
                        _donationMiningMode = MiningModeEnum.Automatic;
                        MiningMode          = _donationMiningMode;
                        _donationMiningTime = TimeSpan.Zero;
                    }
                }

                // Restart miner if max time reached
                if (RestartTime.HasValue && RestartTime.Value <= TimeSpan.Zero)
                {
                    StopMiner();
                }

                foreach (PriceEntryBase entry in _priceEntries)
                {
                    entry.BelowMinPrice = entry.NetEarn < _minPrice;
                }

                // Find the best, live entry
                PriceEntryBase best =
                    _priceEntries
                    .Where(o => !IsBadEntry(o))
                    .Where(o =>
                           !string.IsNullOrWhiteSpace(_donationMiningMode == MiningModeEnum.Donation
                                    ? o.DonationCommand
                                    : o.Command))
                    .OrderByDescending(o => _mineByAverage? o.NetAverage: o.NetEarn)
                    .FirstOrDefault();

                // If none is found, because they're all banned, dead, below minprice
                // All should quit
                if (best == null && _currentRunning != null)
                {
                    StopMiner();
                    return;
                }

                // If the current pool is banned, it should directly start the best one
                if (_currentRunning != null && _currentRunning.Banned &&
                    best.Id != _currentRunning.Id)
                {
                    StopMiner();
                    StartMiner(best, isMinimizedToTray);
                    return;
                }

                decimal highestMinProfit = 1M;

                // Handle minimum time for better algorithm before switching
                if (_switchTime > TimeSpan.Zero && _currentRunning != null)
                {
                    if (!_nextRun.HasValue && _currentRunning.Id != best.Id)
                    {
                        _nextRun         = best.Id;
                        _nextRunFromTime = DateTime.Now;
                    }
                    else if (_nextRun.HasValue && _currentRunning.Id == best.Id)
                    {
                        _nextRun         = null;
                        _nextRunFromTime = null;
                    }

                    _profitBestOverRunning = _mineByAverage? best.NetAverage / _currentRunning.NetAverage : best.NetEarn / _currentRunning.NetEarn;
                    highestMinProfit       = best.ServiceEntry.ServiceEnum != _currentRunning.ServiceEntry.ServiceEnum
                        ? Math.Max(best.MinProfit, _minProfit)
                        : _minProfit;


                    if (NextRunTime.HasValue && NextRunTime > TimeSpan.Zero)
                    {
                        best = _priceEntries.First(o => o.Id == _currentRunning.Id);
                    }
                }

                // Update undead entries
                IEnumerable <PriceEntryBase> entries =
                    PriceEntries.Where(o => !o.IsDead && o.DeadTime != DateTime.MinValue);
                foreach (PriceEntryBase entry in entries)
                {
                    entry.DeadTime = DateTime.MinValue;
                }


                if (_currentRunning != null
                    // Guarantees a minimum profit before switching
                    && (_profitBestOverRunning < highestMinProfit
                        // Keeps outliers pending/ignores them if requested and not mining by average
                        || (!_mineByAverage && _ignoreOutliers && best.Outlier)
                        // Just update time if we are already running the right entry
                        || _currentRunning.Id == best.Id
                        // Honor minimum time to run in auto mode
                        || (MiningTime.HasValue && MiningTime.Value < _minTime)))
                {
                    _currentRunning.UpdateStatus();
                    return;
                }

                StopMiner();
                if (_stoppedMining == null || _stoppedMining + _delay <= DateTime.Now)
                {
                    StartMiner(best, isMinimizedToTray);
                }
            }
            catch (Exception ex)
            {
                ErrorLogger.Log(ex);
            }
        }
Пример #18
0
        public void UpdatePrice(PriceEntryBase priceEntryBase)
        {
            DateTime now   = DateTime.Now;
            decimal  price = priceEntryBase.NetEarn;

            decimal totalPrice = price;
            int     totalCount = PriceList.Count;

            List <decimal> window = new List <decimal> {
                price
            };
            decimal windowedPrice = price;
            int     windowedCount = 0;
            bool    outlier       = false;

            if (!PriceList.ContainsKey(priceEntryBase))
            {
                PriceList.Add(priceEntryBase, new List <PriceStat>());
            }

            foreach (PriceStat stat in PriceList[priceEntryBase])
            {
                decimal historicPrice = stat.CurrentPrice;
                totalPrice += historicPrice;

                if (stat.Time == now)
                {
                    return;
                }
                if (stat.Time >= now - _statWindow)
                {
                    window.Add(historicPrice);
                    windowedPrice += historicPrice;
                    windowedCount++;
                }
            }

            decimal totalAveragePrice    = totalPrice / (totalCount + 1);
            decimal windowedAveragePrice = windowedPrice / (windowedCount + 1);

            if (windowedCount >= 10) // Makes sure at least ten entries are in there
            {
                window.Sort();
                if (_iqrMultiplier > 0)
                {
                    int     iqrIndex = (int)Math.Truncate(window.Count * 0.75);
                    decimal iqr      = window[iqrIndex] - window[window.Count - iqrIndex];
                    outlier = price > windowedAveragePrice + (_iqrMultiplier * iqr);
                }
                else
                {
                    // If the IQR multiplier is negative or zero,
                    // it'll try to use percentiles for outlierdetection
                    // Not advised! Will kill off trending profits, iqr-multiplying is preferable
                    int       outlierIndex = (int)Math.Truncate(window.Count * _percentile);
                    decimal[] outliers     = { window[outlierIndex], window[window.Count - outlierIndex] };
                    outlier = price > outliers.Max();
                }
            }


            PriceStat priceStat = new PriceStat
            {
                Time                 = now,
                CurrentPrice         = price,
                TotalAveragePrice    = totalAveragePrice,
                WindowedAveragePrice = windowedAveragePrice,
                Outlier              = outlier
            };

            priceEntryBase.Outlier    = outlier;
            priceEntryBase.NetAverage = windowedAveragePrice;

            PriceList[priceEntryBase].Add(priceStat);
        }
Пример #19
0
        public void RequestStart(int id, bool isMinimizedToTray = false)
        {
            PriceEntryBase entry = _priceEntries.Single(o => o.Id == id);

            StartMiner(entry, isMinimizedToTray);
        }
Пример #20
0
        private void StartMiner(PriceEntryBase entry, bool isMinimizedToTray = false)
        {
            _nextRun         = null;
            _nextRunFromTime = null;
            _currentRunning  = entry;
            _startMining     = DateTime.Now;
            _stoppedMining   = null;

            _process = new Process();
            if (_donationMiningMode == MiningModeEnum.Donation)
            {
                if (!string.IsNullOrWhiteSpace(entry.DonationFolder))
                {
                    _process.StartInfo.WorkingDirectory = entry.DonationFolder;
                }
                _process.StartInfo.FileName = string.IsNullOrWhiteSpace(entry.DonationFolder)
                    ? entry.DonationCommand
                    : string.Format(@"{0}\{1}", entry.DonationFolder, entry.DonationCommand);
                _process.StartInfo.Arguments = entry.DonationArguments;
            }
            else
            {
                if (!string.IsNullOrWhiteSpace(entry.Folder))
                {
                    _process.StartInfo.WorkingDirectory = entry.Folder;
                }
                _process.StartInfo.FileName = string.IsNullOrWhiteSpace(entry.Folder)
                    ? entry.Command
                    : string.Format(@"{0}\{1}", entry.Folder, entry.Command);
                _process.StartInfo.Arguments = entry.Arguments;
            }

            WriteConsole(
                string.Format("Starting {0} {1} with {2} {3}", _currentRunning.ServicePrint, _currentRunning.Name,
                              _process.StartInfo.FileName, _process.StartInfo.Arguments), true);

            if (!string.IsNullOrWhiteSpace(_process.StartInfo.WorkingDirectory) &&
                !Directory.Exists(_process.StartInfo.WorkingDirectory))
            {
                entry.DeadTime = DateTime.Now;
                string message = string.Format("Path '{0}' does not exist.", _process.StartInfo.WorkingDirectory);
                _process = null;
                WriteConsole(message, true);
                throw new ArgumentException(message);
            }
            if (!string.IsNullOrWhiteSpace(_process.StartInfo.FileName) && !File.Exists(_process.StartInfo.FileName))
            {
                entry.DeadTime = DateTime.Now;
                string message = string.Format("File '{0}' does not exist.", _process.StartInfo.FileName);
                _process = null;
                WriteConsole(message, true);
                throw new ArgumentException(message);
            }

            if (entry.UseWindow)
            {
                _process.StartInfo.WindowStyle = (isMinimizedToTray && TrayMode == 2)
                    ? ProcessWindowStyle.Hidden
                    : ProcessWindowStyle.Minimized;
                _process.Start();

                Thread.Sleep(100);
                try
                {
                    ProcessUtil.SetWindowTitle(_process, string.Format("{0} {1} Miner", entry.ServicePrint, entry.Name));
                }
                catch (Exception ex)
                {
                    ErrorLogger.Log(ex);
                }

                if (isMinimizedToTray && TrayMode == 1)
                {
                    HideMinerWindow();
                }
            }
            else
            {
                _process.StartInfo.RedirectStandardOutput = true;
                _process.StartInfo.RedirectStandardError  = true;
                _process.EnableRaisingEvents       = true;
                _process.StartInfo.CreateNoWindow  = true;
                _process.StartInfo.UseShellExecute = false;

                _process.ErrorDataReceived  += ProcessConsoleOutput;
                _process.OutputDataReceived += ProcessConsoleOutput;

                _process.Start();

                _process.BeginOutputReadLine();
                _process.BeginErrorReadLine();
            }

            ProcessPriorityClass processPriority;

            if (entry.Priority != "Normal" && entry.Priority != string.Empty &&
                Enum.TryParse(entry.Priority, out processPriority))
            {
                // Defaults to Normal, other possible values are Idle, BelowNormal,
                // AboveNormal, High & RealTime. ccminer <3 RealTime
                // Note 1: Realtime by minercontrol is only possible when given administrator privileges to minercontrol
                // Note 2: --cpu-priority by ccminer overrides minercontrols priority
                // Note 3: When giving administrator privileges to minercontrol and setting the priority by minercontrol to
                // something DIFFERENT than what's used by --cpu-priority by ccminer, then your whole system locks up
                _process.PriorityClass = processPriority;
            }

            if (entry.Affinity > 0)
            {
                // Just like with start /affinity, you can use 1 for first core, 2 for second core, 4 for third core, etc
                _process.ProcessorAffinity = (IntPtr)entry.Affinity;
            }

            _startMining        = DateTime.Now;
            _donationMiningMode = MiningMode;

            entry.UpdateStatus();

            LogActivity(_donationMiningMode == MiningModeEnum.Donation ? "DonationStart" : "Start");
        }
Пример #21
0
        private void MPOSSpeed(object RawData)
        {
            if (RawData != null)
            {
                var     hashrate = 0f;
                var     rejected = 0f;
                JObject data     = (JObject)RawData;
                JToken  db       = data["getdashboarddata"];
                JToken  shares   = db["data"]["personal"]["shares"];
                JToken  ExRate   = db["data"]["pool"]["price"];
                JToken  tag      = db["data"]["pool"]["info"]["currency"];
                hashrate = (float)db["data"]["personal"]["hashrate"];
                rejected = hashrate * (float)shares["invalid_percent"] / 100;

                PriceEntryBase entry = GetEntryTag(tag.ToString());
                if (entry != null && hashrate > 0)
                {
                    float m = 1000;

                    switch (ServiceName)
                    {
                    case "Suprnova":
                        if (entry.AlgoName.ToLower().StartsWith("cryptonight") ||
                            entry.AlgoName.ToLower().StartsWith("lbry"))
                        {
                            m = m / 1000;
                        }
                        if (entry.AlgoName.ToLower().StartsWith("equihash"))
                        {
                            m = m / 1000000;
                        }
                        break;

                    case "Dwarfpool":
                        if (entry.AlgoName.ToLower().StartsWith("equihash"))
                        {
                            m = m / 1000;
                        }
                        break;

                    case "MiningPoolHub":
                        if (entry.AlgoName.ToLower().StartsWith("blake") ||
                            entry.AlgoName.ToLower().StartsWith("decred"))
                        {
                            m = m * 1000;
                        }
                        if (entry.AlgoName.ToLower().StartsWith("equihash"))
                        {
                            m = m / 1000000;
                        }
                        if (entry.AlgoName.ToLower().StartsWith("cryptonight"))
                        {
                            m = m / 1000;
                        }
                        break;

                    default:
                        if (entry.AlgoName.ToLower().StartsWith("decred") ||
                            entry.AlgoName.ToLower().StartsWith("lbry"))
                        {
                            m = m * 1000;
                        }
                        if (entry.AlgoName.ToLower().StartsWith("equihash"))
                        {
                            m = m / 1000000;
                        }
                        break;
                    }

                    entry.AcceptSpeed = hashrate.ExtractDecimal() * m.ExtractDecimal();
                    entry.RejectSpeed = rejected.ExtractDecimal() * m.ExtractDecimal();
                }
            }
        }
Пример #22
0
 public bool IsBadEntry(PriceEntryBase priceEntry)
 {
     return(priceEntry.BelowMinPrice || priceEntry.Banned || priceEntry.IsDead);
 }
Пример #23
0
        private void MPOSSpeedWorker(object RawData)
        {
            if (RawData != null)
            {
                JObject data   = (JObject)RawData;
                JToken  db     = data["getuserworkers"];
                JToken  value  = db["data"];
                JToken  status = data["getuserworkers"]["version"];

                PriceEntryBase entry = GetEntryCoin(status.ToString());
                if (entry != null)
                {
                    foreach (var item in value.Children())
                    {
                        var w = item["username"].ToString();
                        var s = (float)item["hashrate"];

                        float m = 1;

                        if (entry.AlgoName.ToLower().StartsWith("equihash"))
                        {
                            s = s / 1000000;
                        }

                        switch (ServiceName)
                        {
                        case "CoinMine":
                            if (entry.AlgoName.ToLower().StartsWith("equihash"))
                            {
                                m = m * 1000;
                            }
                            break;

                        case "Dwarfpool":
                            if (entry.AlgoName.ToLower().StartsWith("equihash"))
                            {
                                m = m / 1000;
                            }
                            break;

                        case "Suprnova":
                            if (entry.Tag.ToLower().StartsWith("zec"))
                            {
                                m = m * 1000;
                            }
                            break;

                        case "AikaPool":
                            if (entry.Tag.ToLower().StartsWith("kmd") ||
                                entry.Tag.ToLower().StartsWith("zdash"))
                            {
                                m = m / 1000;
                            }
                            break;

                        case "MiningPoolHub":
                            if (entry.AlgoName.ToLower().StartsWith("blake") ||
                                entry.AlgoName.ToLower().StartsWith("decred"))
                            {
                                m = m * 1000000;
                            }
                            if (entry.AlgoName.ToLower().StartsWith("equihash"))
                            {
                                m = m * 1000;
                            }
                            break;

                        default:
                            if (entry.AlgoName.ToLower().StartsWith("equihash"))
                            {
                                m = m * 1000;
                            }
                            break;
                        }

                        if (w.ToString().ToLower() == _account.ToString().ToLower() + "." + _worker.ToString().ToLower() && s > 0)
                        {
                            entry.AcSpWrk = s.ExtractDecimal() * m.ExtractDecimal();
                            AverageSpeed(entry);
                        }
                    }
                }
            }
        }