示例#1
0
        /// <summary>
        /// Enable mining pool command line.
        /// </summary>
        private static void EnableMiningPoolCommandLine()
        {
            ThreadMiningPoolCommandLines = new Thread(delegate()
            {
                while (!Exit)
                {
                    string commandLine = Console.ReadLine();
                    try
                    {
                        var splitCommandLine = commandLine.Split(new char[0], StringSplitOptions.None);
                        switch (splitCommandLine[0].ToLower())
                        {
                        case MiningPoolCommandLinesEnumeration.MiningPoolCommandLineHelp:
                            ClassLog.ConsoleWriteLog(MiningPoolCommandLinesEnumeration.MiningPoolCommandLineHelp + " - Command line to get list of commands details.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true);
                            ClassLog.ConsoleWriteLog(MiningPoolCommandLinesEnumeration.MiningPoolCommandLineStats + " - Show mining pool stats.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true);
                            ClassLog.ConsoleWriteLog(MiningPoolCommandLinesEnumeration.MiningPoolCommandLineBanMiner + " - ban a miner wallet address, syntax: " + MiningPoolCommandLinesEnumeration.MiningPoolCommandLineBanMiner + " wallet_address time", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true);
                            ClassLog.ConsoleWriteLog(MiningPoolCommandLinesEnumeration.MiningPoolCommandLineBanMinerList + " - Show the list of miner wallet address banned.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true);
                            ClassLog.ConsoleWriteLog(MiningPoolCommandLinesEnumeration.MiningPoolCommandLineUnBanMiner + " - Permit to unban a wallet address, syntax: " + MiningPoolCommandLinesEnumeration.MiningPoolCommandLineUnBanMiner + " wallet_address", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true);
                            ClassLog.ConsoleWriteLog(MiningPoolCommandLinesEnumeration.MiningPoolCommandLineExit + " - Stop mining pool, save and exit.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true);

                            break;

                        case MiningPoolCommandLinesEnumeration.MiningPoolCommandLineStats:
                            ClassLog.ConsoleWriteLog("Mining Pool Stats: ", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true);
                            ClassLog.ConsoleWriteLog("Total miners connected: " + ClassMiningPoolGlobalStats.TotalWorkerConnected, ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true);
                            ClassLog.ConsoleWriteLog("Total blocks found: " + ClassMiningPoolGlobalStats.TotalBlockFound, ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true);
                            ClassLog.ConsoleWriteLog("Total miners hashrate: " + ClassMiningPoolGlobalStats.TotalMinerHashrate.ToString("F2"), ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true);
                            ClassLog.ConsoleWriteLog("Pool Wallet Total Balance: " + ClassMiningPoolGlobalStats.PoolCurrentBalance + " " + ClassConnectorSetting.CoinNameMin, ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true);
                            ClassLog.ConsoleWriteLog("Pool Wallet Total Balance in Pending: " + ClassMiningPoolGlobalStats.PoolPendingBalance + " " + ClassConnectorSetting.CoinNameMin, ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true);
                            if (ClassNetworkBlockchain.IsConnected)
                            {
                                ClassLog.ConsoleWriteLog("Mining pool is connected to retrieve last blocktemplate.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true);
                            }
                            else
                            {
                                ClassLog.ConsoleWriteLog("Mining pool is not connected to retrieve last blocktemplate.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
                            }
                            break;

                        case MiningPoolCommandLinesEnumeration.MiningPoolCommandLineBanMiner:
                            string walletAddress = splitCommandLine[1];
                            if (!ClassMinerStats.ManualBanWalletAddress(walletAddress, int.Parse(splitCommandLine[2])))
                            {
                                ClassLog.ConsoleWriteLog("Cannot ban wallet address: " + walletAddress + " because this one not exist.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
                            }
                            else
                            {
                                ClassLog.ConsoleWriteLog("Wallet address: " + walletAddress + " is banned successfully pending " + splitCommandLine[2] + " second(s).", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
                            }
                            break;

                        case MiningPoolCommandLinesEnumeration.MiningPoolCommandLineBanMinerList:
                            if (ClassMinerStats.DictionaryMinerStats.Count > 0)
                            {
                                int totalBanned = 0;
                                foreach (var minerStats in ClassMinerStats.DictionaryMinerStats)
                                {
                                    if (minerStats.Value.IsBanned)
                                    {
                                        long minerBanTime = minerStats.Value.DateOfBan - DateTimeOffset.Now.ToUnixTimeSeconds();
                                        ClassLog.ConsoleWriteLog("Wallet address: " + minerStats.Key + " is banned pending: " + minerBanTime + " second(s).", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
                                        totalBanned++;
                                    }
                                    else
                                    {
                                        if (minerStats.Value.TotalBan > MiningPoolSetting.MiningPoolMaxTotalBanMiner)
                                        {
                                            ClassLog.ConsoleWriteLog("Wallet address: " + minerStats.Key + " is banned forever (until to restart the pool or manual unban).", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
                                            totalBanned++;
                                        }
                                    }
                                }
                                if (totalBanned == 0)
                                {
                                    ClassLog.ConsoleWriteLog("Their is any miner(s) banned.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true);
                                }
                            }
                            break;

                        case MiningPoolCommandLinesEnumeration.MiningPoolCommandLineUnBanMiner:
                            if (ClassMinerStats.DictionaryMinerStats.Count > 0)
                            {
                                if (ClassMinerStats.DictionaryMinerStats.ContainsKey(splitCommandLine[1]))
                                {
                                    ClassMinerStats.DictionaryMinerStats[splitCommandLine[1]].DateOfBan = 0;
                                    ClassMinerStats.DictionaryMinerStats[splitCommandLine[1]].IsBanned  = false;
                                    ClassMinerStats.DictionaryMinerStats[splitCommandLine[1]].TotalBan  = 0;
                                    ClassLog.ConsoleWriteLog("Miner wallet address: " + splitCommandLine[1] + " is unbanned.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true);
                                }
                                else
                                {
                                    ClassLog.ConsoleWriteLog("Miner wallet address: " + splitCommandLine[1] + " not exist.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
                                }
                            }
                            else
                            {
                                ClassLog.ConsoleWriteLog("Miner wallet address: " + splitCommandLine[1] + " not exist.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
                            }
                            break;

                        case MiningPoolCommandLinesEnumeration.MiningPoolCommandLineExit:
                            if (ClassPayment.PoolOnSendingTransaction)
                            {
                                ClassLog.ConsoleWriteLog("Can't close mining pool, the pool is currently on sending transaction(s).", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
                            }
                            else
                            {
                                if (ClassPayment.PoolOnProceedBlockReward)
                                {
                                    ClassLog.ConsoleWriteLog("Can't close mining pool, the pool is currently on proceed block reward(s).", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
                                }
                                else
                                {
                                    Exit = true;
                                    new Thread(delegate()
                                    {
                                        if (ListMiningPool.Count > 0)
                                        {
                                            foreach (var miningPool in ListMiningPool)
                                            {
                                                miningPool.Value.StopMiningPool();
                                            }
                                        }
                                        ClassApi.StopApiHttpServer();
                                        ClassMinerStats.StopCheckMinerStats();
                                        ClassPayment.StopAutoPaymentSystem();
                                        ClassFilteringMiner.StopFileringMiner();
                                        ClassMiningPoolDatabase.StopAutoSaveMiningPoolDatabases();
                                        ClassLog.ConsoleWriteLog("Mining pool stopped.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleBlueLog, true);
                                        ClassLog.StopLogSystem();
                                        if (ThreadMiningPoolCommandLines != null && (ThreadMiningPoolCommandLines.IsAlive || ThreadMiningPoolCommandLines != null))
                                        {
                                            ThreadMiningPoolCommandLines.Abort();
                                            GC.SuppressFinalize(ThreadMiningPoolCommandLines);
                                        }
                                    }).Start();
                                }
                            }
                            break;
                        }
                    }
                    catch (Exception error)
                    {
                        ClassLog.ConsoleWriteLog("Error on command line: " + commandLine + " exception: " + error.Message, ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
                    }
                }
            });
            ThreadMiningPoolCommandLines.Start();
        }
示例#2
0
        /// <summary>
        /// Initialization of the mining pool.
        /// </summary>
        /// <returns></returns>
        private static bool InitializeMiningPool()
        {
            ClassLog.ConsoleWriteLog("Initialize Log system..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);

            if (ClassLog.LogInitialization())
            {
                ClassLog.ConsoleWriteLog("Initialize pool settings..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
                if (MiningPoolSettingInitialization.InitializationPoolSettingFile())
                {
                    ClassLog.ConsoleWriteLog("Pool settings initialized.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true);

                    ClassLog.ConsoleWriteLog("Intialize pool databases..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
                    if (ClassMiningPoolDatabase.InitializationMiningPoolDatabases())
                    {
                        ClassMiningPoolDatabase.AutoSaveMiningPoolDatabases();

                        ClassLog.ConsoleWriteLog("Pool databases initialized.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true);

                        ClassLog.ConsoleWriteLog("Log System initialized.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true);

                        ThreadNetworkBlockchain = new Thread(async delegate()
                        {
                            ClassLog.ConsoleWriteLog("Connect Pool to the network for retrieve current blocktemplate..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);

                            bool notConnected = true;
                            while (notConnected)
                            {
                                Certificate = ClassUtils.GenerateCertificate();

                                while (!await ClassNetworkBlockchain.ConnectToBlockchainAsync())
                                {
                                    Thread.Sleep(5000);
                                    ClassLog.ConsoleWriteLog("Can't connect Pool to the network, retry in 5 seconds.. (Press CTRL+C to cancel and close the pool.)", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
                                }
                                Certificate = ClassUtils.GenerateCertificate();
                                ClassLog.ConsoleWriteLog("Certificate generate, send to the network..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
                                if (!await ClassNetworkBlockchain.SendPacketToNetworkBlockchain(Certificate, false))
                                {
                                    ClassLog.ConsoleWriteLog("Can't send certificate, reconnect now..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
                                }
                                else
                                {
                                    ClassLog.ConsoleWriteLog("Certificate sent, start to login..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
                                    ClassNetworkBlockchain.ListenBlockchain();
                                    Thread.Sleep(1000);
                                    if (!await ClassNetworkBlockchain.SendPacketToNetworkBlockchain(ClassConnectorSettingEnumeration.MinerLoginType + "|" + MiningPoolSetting.MiningPoolWalletAddress, true))
                                    {
                                        ClassLog.ConsoleWriteLog("Can't login to the network, reconnect now.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
                                    }
                                    else
                                    {
                                        ClassLog.ConsoleWriteLog("Login successfully sent, waiting confirmation..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
                                        notConnected = false;
                                    }
                                }
                                if (notConnected)
                                {
                                    ClassLog.ConsoleWriteLog("Can't long Pool to the network, retry in 5 seconds.. (Press CTRL+C to cancel and close the pool.)", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
                                    Thread.Sleep(5000);
                                }
                                else
                                {
                                    break;
                                }
                            }
                        })
                        {
                            IsBackground = true
                        };
                        ThreadNetworkBlockchain.Start();
                        if (MiningPoolSetting.MiningPoolEnableFiltering)
                        {
                            ClassLog.ConsoleWriteLog("Enable Filtering Miner System..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
                            ClassFilteringMiner.EnableFilteringMiner();
                        }
                        if (MiningPoolSetting.MiningPoolEnableCheckMinerStats)
                        {
                            ClassLog.ConsoleWriteLog("Enable Check Miner Stats System..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
                            ClassMinerStats.EnableCheckMinerStats();
                        }
                        if (MiningPoolSetting.MiningPoolEnableTrustedShare)
                        {
                            ClassLog.ConsoleWriteLog("Enable Trusted Share System..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
                            ClassMinerStats.EnableCheckTrustedMinerStats();
                        }
                        if (MiningPoolSetting.MiningPoolEnablePayment)
                        {
                            ClassPayment.EnableAutoPaymentSystem();
                        }
                        if (MiningPoolSetting.MiningPoolMiningPort.Count > 0)
                        {
                            foreach (var miningPoolPort in MiningPoolSetting.MiningPoolMiningPort)
                            {
                                var miningPoolObject = new ClassMiningPool(miningPoolPort.Key, miningPoolPort.Value);
                                miningPoolObject.StartMiningPool();
                                ListMiningPool.Add(miningPoolPort.Key, miningPoolObject);
                            }
                            ClassApi.StartApiHttpServer();
                            EnableMiningPoolCommandLine();
                        }
                        else
                        {
                            ClassLog.ConsoleWriteLog("Cannot start mining pool, their is any ports on the setting.", ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
                            return(false);
                        }
                    }
                    else
                    {
                        return(false);
                    }
                }
                else
                {
                    return(false);
                }
            }
            else
            {
                return(false);
            }
            return(true);
        }
示例#3
0
        /// <summary>
        /// Handle packet received from the network.
        /// </summary>
        /// <param name="packet"></param>
        private static async Task HandlePacketNetworkAsync(string packet)
        {
            packet = packet.Replace("*", "");
            var packetSplit = packet.Split(new[] { "|" }, StringSplitOptions.None);

            switch (packetSplit[0])
            {
            case ClassSoloMiningPacketEnumeration.SoloMiningRecvPacketEnumeration.SendLoginAccepted:
                LoginAccepted = true;
                ClassLog.ConsoleWriteLog("Mining pool logged successfully to the blockchain network.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true);
                AskMiningMethod();
                break;

            case ClassSoloMiningPacketEnumeration.SoloMiningRecvPacketEnumeration.SendListBlockMethod:
                var methodList = packetSplit[1];
                if (methodList.Contains("#"))
                {
                    var splitMethodList = methodList.Split(new[] { "#" }, StringSplitOptions.None);
                    if (ListOfMiningMethodName.Count > 1)
                    {
                        foreach (var methodName in splitMethodList)
                        {
                            if (!string.IsNullOrEmpty(methodName))
                            {
                                if (ListOfMiningMethodName.Contains(methodName) == false)
                                {
                                    ListOfMiningMethodName.Add(methodName);
                                }
                                if (!await SendPacketToNetworkBlockchain(ClassSoloMiningPacketEnumeration.SoloMiningSendPacketEnumeration.ReceiveAskContentBlockMethod + "|" + methodName, true).ConfigureAwait(false))
                                {
                                    IsConnected = false;
                                    break;
                                }

                                await Task.Delay(1000);
                            }
                        }
                    }
                    else
                    {
                        foreach (var methodName in splitMethodList)
                        {
                            if (!string.IsNullOrEmpty(methodName))
                            {
                                if (ListOfMiningMethodName.Contains(methodName) == false)
                                {
                                    ListOfMiningMethodName.Add(methodName);
                                }
                                if (!await SendPacketToNetworkBlockchain(ClassSoloMiningPacketEnumeration.SoloMiningSendPacketEnumeration.ReceiveAskContentBlockMethod + "|" + methodName, true).ConfigureAwait(false))
                                {
                                    IsConnected = false;
                                    break;
                                }
                                await Task.Delay(1000);
                            }
                        }
                    }
                }
                else
                {
                    if (ListOfMiningMethodName.Contains(methodList) == false)
                    {
                        ListOfMiningMethodName.Add(methodList);
                    }

                    if (!await SendPacketToNetworkBlockchain(ClassSoloMiningPacketEnumeration.SoloMiningSendPacketEnumeration.ReceiveAskContentBlockMethod + "|" + methodList, true).ConfigureAwait(false))
                    {
                        IsConnected = false;
                    }
                }
                break;

            case ClassSoloMiningPacketEnumeration.SoloMiningRecvPacketEnumeration.SendContentBlockMethod:
                if (ListOfMiningMethodContent.Count == 0)
                {
                    ListOfMiningMethodContent.Add(packetSplit[1]);
                }
                else
                {
                    ListOfMiningMethodContent[0] = packetSplit[1];
                }
                break;

            case ClassSoloMiningPacketEnumeration.SoloMiningRecvPacketEnumeration.SendCurrentBlockMining:
                if (packetSplit[1] != ClassMiningPoolGlobalStats.CurrentBlockTemplate)
                {
                    var splitBlockContent = packetSplit[1].Split(new[] { "&" }, StringSplitOptions.None);
                    if (splitBlockContent[0].Replace("ID=", "") != "" && splitBlockContent[0].Replace("ID=", "").Length > 0)
                    {
                        if (splitBlockContent[0].Replace("ID=", "") != ClassMiningPoolGlobalStats.CurrentBlockId)
                        {
                            ClassMiningPoolGlobalStats.CurrentBlockId              = splitBlockContent[0].Replace("ID=", "");
                            ClassMiningPoolGlobalStats.CurrentBlockHash            = splitBlockContent[1].Replace("HASH=", "");
                            ClassMiningPoolGlobalStats.CurrentBlockAlgorithm       = splitBlockContent[2].Replace("ALGORITHM=", "");
                            ClassMiningPoolGlobalStats.CurrentBlockSize            = splitBlockContent[3].Replace("SIZE=", "");
                            ClassMiningPoolGlobalStats.CurrentBlockMethod          = splitBlockContent[4].Replace("METHOD=", "");
                            ClassMiningPoolGlobalStats.CurrentBlockKey             = splitBlockContent[5].Replace("KEY=", "");
                            ClassMiningPoolGlobalStats.CurrentBlockJob             = splitBlockContent[6].Replace("JOB=", "");
                            ClassMiningPoolGlobalStats.CurrentBlockJobMinRange     = decimal.Parse(ClassMiningPoolGlobalStats.CurrentBlockJob.Split(new[] { ";" }, StringSplitOptions.None)[0]);
                            ClassMiningPoolGlobalStats.CurrentBlockJobMaxRange     = decimal.Parse(ClassMiningPoolGlobalStats.CurrentBlockJob.Split(new[] { ";" }, StringSplitOptions.None)[1]);
                            ClassMiningPoolGlobalStats.CurrentBlockReward          = splitBlockContent[7].Replace("REWARD=", "");
                            ClassMiningPoolGlobalStats.CurrentBlockDifficulty      = splitBlockContent[8].Replace("DIFFICULTY=", "");
                            ClassMiningPoolGlobalStats.CurrentBlockTimestampCreate = splitBlockContent[9].Replace("TIMESTAMP=", "");
                            ClassMiningPoolGlobalStats.CurrentBlockIndication      = splitBlockContent[10].Replace("INDICATION=", "");
                            ClassMiningPoolGlobalStats.CurrentBlockTemplate        = packetSplit[1];
                            int idMethod = 0;
                            if (ListOfMiningMethodName.Count > 0)
                            {
                                for (int i = 0; i < ListOfMiningMethodName.Count; i++)
                                {
                                    if (i < ListOfMiningMethodName.Count)
                                    {
                                        if (ListOfMiningMethodName[i] == ClassMiningPoolGlobalStats.CurrentBlockMethod)
                                        {
                                            idMethod = i;
                                        }
                                    }
                                }
                            }
                            var splitMethod = ListOfMiningMethodContent[idMethod].Split(new[] { "#" }, StringSplitOptions.None);
                            ClassMiningPoolGlobalStats.CurrentRoundAesRound = int.Parse(splitMethod[0]);
                            ClassMiningPoolGlobalStats.CurrentRoundAesSize  = int.Parse(splitMethod[1]);
                            ClassMiningPoolGlobalStats.CurrentRoundAesKey   = splitMethod[2];
                            ClassMiningPoolGlobalStats.CurrentRoundXorKey   = int.Parse(splitMethod[3]);
                            using (var pdb = new PasswordDeriveBytes(ClassMiningPoolGlobalStats.CurrentBlockKey, Encoding.UTF8.GetBytes(ClassMiningPoolGlobalStats.CurrentRoundAesKey)))
                            {
                                ClassMiningPoolGlobalStats.CurrentAesKeyIv = pdb.GetBytes(ClassMiningPoolGlobalStats.CurrentRoundAesSize / 8);
                                ClassMiningPoolGlobalStats.CurrentAesSalt  = pdb.GetBytes(ClassMiningPoolGlobalStats.CurrentRoundAesSize / 8);
                            }


                            if (ClassMinerStats.DictionaryMinerStats.Count > 0)
                            {
                                foreach (var miner in ClassMinerStats.DictionaryMinerStats)
                                {
                                    if (miner.Value.ListOfMinerTcpObject.Count > 0)
                                    {
                                        for (int i = 0; i < miner.Value.ListOfMinerTcpObject.Count; i++)
                                        {
                                            if (i < miner.Value.ListOfMinerTcpObject.Count)
                                            {
                                                if (miner.Value.ListOfMinerTcpObject[i] != null)
                                                {
                                                    if (miner.Value.ListOfMinerTcpObject[i].IsLogged)
                                                    {
                                                        miner.Value.ListOfMinerTcpObject[i].MiningPoolSendJobAsync(miner.Value.ListOfMinerTcpObject[i].CurrentMiningJobDifficulty);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            ClassLog.ConsoleWriteLog("New block to mining id: " + ClassMiningPoolGlobalStats.CurrentBlockId + " difficulty: " + ClassMiningPoolGlobalStats.CurrentBlockDifficulty + " hash: " + ClassMiningPoolGlobalStats.CurrentBlockHash, ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleBlueLog, true);
                            ClassLog.ConsoleWriteLog("Current Mining Method: " + ClassMiningPoolGlobalStats.CurrentBlockMethod + " = AES ROUND: " + ClassMiningPoolGlobalStats.CurrentRoundAesRound + " AES SIZE: " + ClassMiningPoolGlobalStats.CurrentRoundAesSize + " AES BYTE KEY: " + ClassMiningPoolGlobalStats.CurrentRoundAesKey + " XOR KEY: " + ClassMiningPoolGlobalStats.CurrentRoundXorKey, ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleBlueLog, true);
                        }
                        else
                        {
                            if (splitBlockContent[1].Replace("HASH=", "") != ClassMiningPoolGlobalStats.CurrentBlockHash)
                            {
                                ClassMiningPoolGlobalStats.CurrentBlockId              = splitBlockContent[0].Replace("ID=", "");
                                ClassMiningPoolGlobalStats.CurrentBlockHash            = splitBlockContent[1].Replace("HASH=", "");
                                ClassMiningPoolGlobalStats.CurrentBlockAlgorithm       = splitBlockContent[2].Replace("ALGORITHM=", "");
                                ClassMiningPoolGlobalStats.CurrentBlockSize            = splitBlockContent[3].Replace("SIZE=", "");
                                ClassMiningPoolGlobalStats.CurrentBlockMethod          = splitBlockContent[4].Replace("METHOD=", "");
                                ClassMiningPoolGlobalStats.CurrentBlockKey             = splitBlockContent[5].Replace("KEY=", "");
                                ClassMiningPoolGlobalStats.CurrentBlockJob             = splitBlockContent[6].Replace("JOB=", "");
                                ClassMiningPoolGlobalStats.CurrentBlockJobMinRange     = decimal.Parse(ClassMiningPoolGlobalStats.CurrentBlockJob.Split(new[] { ";" }, StringSplitOptions.None)[0]);
                                ClassMiningPoolGlobalStats.CurrentBlockJobMaxRange     = decimal.Parse(ClassMiningPoolGlobalStats.CurrentBlockJob.Split(new[] { ";" }, StringSplitOptions.None)[1]);
                                ClassMiningPoolGlobalStats.CurrentBlockReward          = splitBlockContent[7].Replace("REWARD=", "");
                                ClassMiningPoolGlobalStats.CurrentBlockDifficulty      = splitBlockContent[8].Replace("DIFFICULTY=", "");
                                ClassMiningPoolGlobalStats.CurrentBlockTimestampCreate = splitBlockContent[9].Replace("TIMESTAMP=", "");
                                ClassMiningPoolGlobalStats.CurrentBlockIndication      = splitBlockContent[10].Replace("INDICATION=", "");
                                ClassMiningPoolGlobalStats.CurrentBlockTemplate        = packetSplit[1];

                                int idMethod = 0;
                                if (ListOfMiningMethodName.Count > 0)
                                {
                                    for (int i = 0; i < ListOfMiningMethodName.Count; i++)
                                    {
                                        if (i < ListOfMiningMethodName.Count)
                                        {
                                            if (ListOfMiningMethodName[i] == ClassMiningPoolGlobalStats.CurrentBlockMethod)
                                            {
                                                idMethod = i;
                                            }
                                        }
                                    }
                                }
                                var splitMethod = ListOfMiningMethodContent[idMethod].Split(new[] { "#" }, StringSplitOptions.None);
                                ClassMiningPoolGlobalStats.CurrentRoundAesRound = int.Parse(splitMethod[0]);
                                ClassMiningPoolGlobalStats.CurrentRoundAesSize  = int.Parse(splitMethod[1]);
                                ClassMiningPoolGlobalStats.CurrentRoundAesKey   = splitMethod[2];
                                ClassMiningPoolGlobalStats.CurrentRoundXorKey   = int.Parse(splitMethod[3]);
                                using (var pdb = new PasswordDeriveBytes(ClassMiningPoolGlobalStats.CurrentBlockKey, Encoding.UTF8.GetBytes(ClassMiningPoolGlobalStats.CurrentRoundAesKey)))
                                {
                                    ClassMiningPoolGlobalStats.CurrentAesKeyIv = pdb.GetBytes(ClassMiningPoolGlobalStats.CurrentRoundAesSize / 8);
                                    ClassMiningPoolGlobalStats.CurrentAesSalt  = pdb.GetBytes(ClassMiningPoolGlobalStats.CurrentRoundAesSize / 8);
                                }
                                if (ClassMinerStats.DictionaryMinerStats.Count > 0)
                                {
                                    foreach (var miner in ClassMinerStats.DictionaryMinerStats)
                                    {
                                        if (miner.Value.ListOfMinerTcpObject.Count > 0)
                                        {
                                            for (int i = 0; i < miner.Value.ListOfMinerTcpObject.Count; i++)
                                            {
                                                if (i < miner.Value.ListOfMinerTcpObject.Count)
                                                {
                                                    if (miner.Value.ListOfMinerTcpObject[i] != null)
                                                    {
                                                        if (miner.Value.ListOfMinerTcpObject[i].IsLogged)
                                                        {
                                                            miner.Value.ListOfMinerTcpObject[i].MiningPoolSendJobAsync(miner.Value.ListOfMinerTcpObject[i].CurrentMiningJobDifficulty);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                ClassLog.ConsoleWriteLog("Renewed block to mining id: " + ClassMiningPoolGlobalStats.CurrentBlockId + " difficulty: " + ClassMiningPoolGlobalStats.CurrentBlockDifficulty + " hash: " + ClassMiningPoolGlobalStats.CurrentBlockHash, ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleBlueLog, true);
                                ClassLog.ConsoleWriteLog("Current Mining Method: " + ClassMiningPoolGlobalStats.CurrentBlockMethod + " = AES ROUND: " + ClassMiningPoolGlobalStats.CurrentRoundAesRound + " AES SIZE: " + ClassMiningPoolGlobalStats.CurrentRoundAesSize + " AES BYTE KEY: " + ClassMiningPoolGlobalStats.CurrentRoundAesKey + " XOR KEY: " + ClassMiningPoolGlobalStats.CurrentRoundXorKey, ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleBlueLog, true);
                            }
                        }
                    }
                }
                break;

            case ClassSoloMiningPacketEnumeration.SoloMiningRecvPacketEnumeration.SendJobStatus:
                switch (packetSplit[1])
                {
                case ClassSoloMiningPacketEnumeration.SoloMiningRecvPacketEnumeration.ShareUnlock:
                    ClassLog.ConsoleWriteLog("Block ID: " + packetSplit[2] + " has been successfully found and accepted by Blockchain !", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true);
                    ClassMiningPoolGlobalStats.ListBlockFound.Add(ClassMiningPoolGlobalStats.ListBlockFound.Count, int.Parse(packetSplit[2]) + "|" + ClassUtility.GetCurrentDateInSecond());
                    await Task.Factory.StartNew(() => ClassPayment.ProceedMiningScoreRewardAsync(packetSplit[2]), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Current).ConfigureAwait(false);

                    break;

                case ClassSoloMiningPacketEnumeration.SoloMiningRecvPacketEnumeration.ShareBad:
                    ClassLog.ConsoleWriteLog("Block ID: " + packetSplit[2] + " has been found by someone else before the pool or the share sent is invalid.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
                    break;

                case ClassSoloMiningPacketEnumeration.SoloMiningRecvPacketEnumeration.ShareAleady:
                    ClassLog.ConsoleWriteLog("Block ID: " + packetSplit[2] + " is already found by someone else.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
                    break;
                }
                break;
            }
        }