/// <summary>
///
/// </summary>
/// <param name="walletAddressTarget"></param>
/// <returns></returns>
public static async Task <string> SendTransaction(string walletAddressTarget, decimal amount, bool anonymous = false)
{
ClassLog.ConsoleWriteLog("Try to send a transaction to wallet address target: " + walletAddressTarget + " of amount: " + amount + " " + ClassConnectorSetting.CoinNameMin, ClassLogEnumeration.IndexPoolWalletLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
try
{
int anonymousTransaction = anonymous ? 1: 0;
string request = "send_transaction_by_wallet_address|" + MiningPoolSetting.MiningPoolWalletAddress + "|" + amount + "|" + MiningPoolSetting.MiningPoolFeeTransactionPayment + "|" + anonymousTransaction + "|" + walletAddressTarget;
string result = await ProceedHttpRequest("http://" + MiningPoolSetting.MiningPoolRpcWalletHost + ":" + MiningPoolSetting.MiningPoolRpcWalletPort + "/", request);
JObject resultJson = JObject.Parse(result);
if (resultJson["result"].ToString() != "not_exist")
{
ClassMiningPoolGlobalStats.PoolCurrentBalance = decimal.Parse(resultJson["wallet_balance"].ToString().Replace(".", ","), NumberStyles.Currency, Program.GlobalCultureInfo);
ClassMiningPoolGlobalStats.PoolPendingBalance = decimal.Parse(resultJson["wallet_pending_balance"].ToString().Replace(".", ","), NumberStyles.Currency, Program.GlobalCultureInfo);
ClassLog.ConsoleWriteLog("Pool current balance: " + ClassMiningPoolGlobalStats.PoolCurrentBalance + " " + ClassConnectorSetting.CoinNameMin, ClassLogEnumeration.IndexPoolWalletLog);
ClassLog.ConsoleWriteLog("Pool pending balance: " + ClassMiningPoolGlobalStats.PoolPendingBalance + " " + ClassConnectorSetting.CoinNameMin, ClassLogEnumeration.IndexPoolWalletLog);
return(resultJson["result"].ToString() + "|" + resultJson["hash"].ToString());
}
else
{
return(string.Empty);
}
}
catch (Exception error)
{
ClassLog.ConsoleWriteLog("Send transaction failed, exception error: " + error.Message, ClassLogEnumeration.IndexPoolWalletErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
return(string.Empty);
}
/// <summary>
/// This method permit to get back the real ip behind a proxy and check the list of banned IP.
/// </summary>
private bool GetAndCheckForwardedIp(string packet)
{
var splitPacket = packet.Split(new[] { "\n" }, StringSplitOptions.None);
foreach (var packetEach in splitPacket)
{
if (packetEach != null)
{
if (!string.IsNullOrEmpty(packetEach))
{
if (packetEach.ToLower().Contains("x-forwarded-for: "))
{
_ip = packetEach.ToLower().Replace("x-forwarded-for: ", "");
ClassLog.ConsoleWriteLog("HTTP/HTTPS API - X-Forwarded-For ip of the client is: " + _ip, ClassLogEnumeration.IndexPoolApiLog, ClassLogEnumeration.IndexPoolApiErrorLog);
if (ClassFilteringMiner.CheckMinerIsBannedByIP(_ip))
{
return(false);
}
}
}
}
}
return(true);
}
public static async Task <bool> GetCurrentBalance()
{
ClassLog.ConsoleWriteLog("Update current pool balance..", ClassLogEnumeration.IndexPoolWalletLog);
try
{
string request = "get_wallet_balance_by_wallet_address|" + MiningPoolSetting.MiningPoolWalletAddress;
string result = await ProceedHttpRequest("http://" + MiningPoolSetting.MiningPoolRpcWalletHost + ":" + MiningPoolSetting.MiningPoolRpcWalletPort + "/", request);
JObject resultJson = JObject.Parse(result);
if (resultJson.ContainsKey("wallet_address"))
{
ClassMiningPoolGlobalStats.PoolCurrentBalance = decimal.Parse(resultJson["wallet_balance"].ToString().Replace(".", ","), NumberStyles.Currency, Program.GlobalCultureInfo);
ClassMiningPoolGlobalStats.PoolPendingBalance = decimal.Parse(resultJson["wallet_pending_balance"].ToString().Replace(".", ","), NumberStyles.Currency, Program.GlobalCultureInfo);
ClassLog.ConsoleWriteLog("Pool current balance: " + ClassMiningPoolGlobalStats.PoolCurrentBalance + " " + ClassConnectorSetting.CoinNameMin, ClassLogEnumeration.IndexPoolWalletLog);
ClassLog.ConsoleWriteLog("Pool pending balance: " + ClassMiningPoolGlobalStats.PoolPendingBalance + " " + ClassConnectorSetting.CoinNameMin, ClassLogEnumeration.IndexPoolWalletLog);
return(true);
}
}
catch (Exception error)
{
ClassLog.ConsoleWriteLog("Update current pool balance failed, exception error: " + error.Message, ClassLogEnumeration.IndexPoolWalletErrorLog);
return(false);
}
return(false);
}
/// <summary>
/// Listen Blockchain packet.
/// </summary>
public static void ListenBlockchain()
{
if (ThreadListenBlockchain != null && (ThreadListenBlockchain.IsAlive || ThreadListenBlockchain != null))
{
ThreadListenBlockchain.Abort();
GC.SuppressFinalize(ThreadListenBlockchain);
}
ThreadListenBlockchain = new Thread(async delegate()
{
while (IsConnected && !Program.Exit)
{
try
{
string packet = await classSeedNodeConnector.ReceivePacketFromSeedNodeAsync(Program.Certificate, false, true).ConfigureAwait(false);
if (packet == ClassSeedNodeStatus.SeedError)
{
ClassLog.ConsoleWriteLog("Connection to network lost, reconnect in 5 seconds..", ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
IsConnected = false;
break;
}
_lastPacketReceivedFromBlockchain = DateTimeOffset.Now.ToUnixTimeSeconds();
if (packet.Contains("*"))
{
var splitPacket = packet.Split(new[] { "*" }, StringSplitOptions.None);
if (splitPacket.Length > 1)
{
foreach (var packetEach in splitPacket)
{
if (packetEach != null)
{
if (!string.IsNullOrEmpty(packetEach))
{
await HandlePacketNetworkAsync(packetEach.Replace("*", ""));
}
}
}
}
else
{
await HandlePacketNetworkAsync(packet.Replace("*", ""));
}
}
else
{
await HandlePacketNetworkAsync(packet);
}
}
catch
{
ClassLog.ConsoleWriteLog("Connection to network lost, reconnect in 5 seconds..", ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
IsConnected = false;
break;
}
}
});
ThreadListenBlockchain.Start();
}
/// <summary>
/// Send packet share for attempt to unlock the block.
/// </summary>
/// <param name="encryptedShare"></param>
/// <param name="result"></param>
/// <param name="math"></param>
/// <param name="hashShare"></param>
public static async void SendPacketBlockFound(string encryptedShare, decimal result, string math, string hashShare)
{
string packetShare = ClassSoloMiningPacketEnumeration.SoloMiningSendPacketEnumeration.ReceiveJob + "|" + encryptedShare + "|" + result + "|" + math + "|" + hashShare + "|" + ClassMiningPoolGlobalStats.CurrentBlockId + "|Mining Pool Tool - " + Assembly.GetExecutingAssembly().GetName().Version + "R";
if (!await SendPacketToNetworkBlockchain(packetShare, true))
{
IsConnected = false;
ClassLog.ConsoleWriteLog("Warning cannot send packet for attempt to unlock the block id " + ClassMiningPoolGlobalStats.CurrentBlockId + ", network connection lost.", ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
}
/// <summary>
/// Remove a rules of banning to the firewall.
/// </summary>
/// <param name="ip"></param>
public static void RemoveFirewallRules(string ip)
{
switch (MiningPoolSetting.MiningPoolLinkFirewallFilteringName.ToLower())
{
case ClassFilteringEnumerationFirewallName.IptableFirewall:
Process.Start("/bin/bash", "-c \"iptables -D INPUT -p tcp -s " + ip + " -j " + MiningPoolSetting.MiningPoolLinkFirewallFilteringTableName + "\""); // Add iptables rules.
break;
case ClassFilteringEnumerationFirewallName.PacketFilterFirewall:
Process.Start("pfctl", "-t " + MiningPoolSetting.MiningPoolLinkFirewallFilteringTableName + " -T del " + ip + ""); // Add iptables rules.
break;
default:
ClassLog.ConsoleWriteLog("Warning " + MiningPoolSetting.MiningPoolLinkFirewallFilteringName + " not exist.", 2, 2, true);
break;
}
}
/// <summary>
/// Stop Api HTTP Server
/// </summary>
public static void StopApiHttpServer()
{
ClassLog.ConsoleWriteLog("Stop mining pool API HTTP..", ClassLogEnumeration.IndexPoolApiLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
ListenApiHttpConnectionStatus = false;
if (ThreadListenApiHttpConnection != null && (ThreadListenApiHttpConnection.IsAlive || ThreadListenApiHttpConnection != null))
{
ThreadListenApiHttpConnection.Abort();
GC.SuppressFinalize(ThreadListenApiHttpConnection);
}
try
{
ListenerApiHttpConnection.Stop();
}
catch
{
}
ClassLog.ConsoleWriteLog("Mining pool API HTTP stopped.", ClassLogEnumeration.IndexPoolApiLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true);
}
/// <summary>
/// Insert an invalid wallet address to the firewall.
/// </summary>
/// <param name="walletAddress"></param>
/// <param name="ip"></param>
public static void InsertInvalidWalletAddress(string walletAddress, string ip)
{
try
{
if (DictionaryFilteringInvalidWalletAddress.Count >= (int.MaxValue - 100000)) // Just in case.
{
DictionaryFilteringInvalidWalletAddress.Clear();
}
if (!DictionaryFilteringInvalidWalletAddress.ContainsKey(walletAddress))
{
DictionaryFilteringInvalidWalletAddress.Add(walletAddress, ip);
ClassLog.ConsoleWriteLog("Warning invalid wallet address: " + walletAddress + " from ip: " + ip + " insert to the cache.", 2, 2, true);
}
else
{
ClassLog.ConsoleWriteLog("Warning invalid wallet address: " + walletAddress + " from ip: " + ip + " already inserted to the cache.", 2, 2, true);
}
}
catch
{
}
}
/// <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);
}
/// <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();
}
private const int CheckFilteringMinerInterval = 1000; // Check every 1000 ms.
/// <summary>
/// Enable filtering miner system.
/// </summary>
public static void EnableFilteringMiner()
{
if (MiningPoolSetting.MiningPoolFilteringMinimumInvalidPacket > 0)
{
if (MiningPoolSetting.MiningPoolFileringBanTime > 0)
{
ThreadFilteringMiner = new Thread(delegate()
{
while (true)
{
try
{
if (DictionaryFilteringObjectMiner.Count > 0)
{
foreach (var filteringObject in DictionaryFilteringObjectMiner)
{
if (filteringObject.Value.IsBanned)
{
if (filteringObject.Value.DateOfBan < DateTimeOffset.Now.ToUnixTimeSeconds())
{
filteringObject.Value.IsBanned = false;
filteringObject.Value.TotalInvalidPacket = 0;
ClassLog.ConsoleWriteLog("Unbanned IP: " + filteringObject.Key + ".", 3);
if (MiningPoolSetting.MiningPoolEnableLinkFirewallFiltering)
{
RemoveFirewallRules(filteringObject.Key);
}
}
}
else
{
if (filteringObject.Value.DateOfBan >= DateTimeOffset.Now.ToUnixTimeSeconds())
{
filteringObject.Value.IsBanned = true;
filteringObject.Value.DateOfBan = DateTimeOffset.Now.ToUnixTimeSeconds() + MiningPoolSetting.MiningPoolFileringBanTime;
ClassLog.ConsoleWriteLog("Banned IP: " + filteringObject.Key + ".", 3);
if (MiningPoolSetting.MiningPoolEnableLinkFirewallFiltering)
{
InsertFirewallRules(filteringObject.Key);
}
}
else if (filteringObject.Value.TotalInvalidPacket >= MiningPoolSetting.MiningPoolFilteringMinimumInvalidPacket)
{
filteringObject.Value.IsBanned = true;
filteringObject.Value.DateOfBan = DateTimeOffset.Now.ToUnixTimeSeconds() + MiningPoolSetting.MiningPoolFileringBanTime;
ClassLog.ConsoleWriteLog("Banned IP: " + filteringObject.Key + ".", 3);
if (MiningPoolSetting.MiningPoolEnableLinkFirewallFiltering)
{
InsertFirewallRules(filteringObject.Key);
}
}
}
}
}
}
catch (Exception error)
{
ClassLog.ConsoleWriteLog("Filtering system exception error: " + error.Message, 2);
}
Thread.Sleep(CheckFilteringMinerInterval);
}
});
ThreadFilteringMiner.Start();
}
else
{
// Warning ban time should be higher than 0 seconds, the system will not be enabled.
ClassLog.ConsoleWriteLog("Warning ban time should be higher than 0 seconds, the system will not be enabled.", 2, 2, true);
}
}
else
{
// Warning the limit of invalid share should be higher than 0, the system will not be enabled.
ClassLog.ConsoleWriteLog("Warning the limit of invalid share should be higher than 0, the system will not be enabled.", 2, 2, true);
}
if (MiningPoolSetting.MiningPoolFilteringIntervalCleanInvalidPacket > 0)
{
ThreadCleanFilteringMiner = new Thread(delegate()
{
while (true)
{
try
{
if (DictionaryFilteringObjectMiner.Count > 0)
{
foreach (var filteringObject in DictionaryFilteringObjectMiner)
{
if (!filteringObject.Value.IsBanned)
{
filteringObject.Value.TotalInvalidPacket = 0;
ClassLog.ConsoleWriteLog("Cleaning total invalid packet for IP: " + filteringObject.Key + ".", 3);
}
}
}
}
catch (Exception error)
{
ClassLog.ConsoleWriteLog("Filtering clean system exception error: " + error.Message, 2);
}
Thread.Sleep(MiningPoolSetting.MiningPoolFilteringIntervalCleanInvalidPacket * 1000);
}
});
ThreadCleanFilteringMiner.Start();
}
else
{
// Warning the interval of time necessary for clean up total invalid packet should be higher than 0, the cleaning system will not be enabled.
ClassLog.ConsoleWriteLog("Warning the interval of time necessary for clean up total invalid packet should be higher than 0, the cleaning system will not be enabled.", 2, 2, true);
}
}
/// <summary>
/// Check miner stats.
/// </summary>
public static void EnableCheckMinerStats()
{
if (MiningPoolSetting.MiningPoolMinimumInvalidShare > 0)
{
if (MiningPoolSetting.MiningPoolMinerBanTime > 0)
{
ThreadCheckMinerStats = new Thread(delegate()
{
while (!Program.Exit)
{
try
{
if (DictionaryMinerStats.Count > 0)
{
int totalConnectedMiner = 0;
int totalConnectedWorker = 0;
foreach (var minerStats in DictionaryMinerStats)
{
if (minerStats.Value.IsBanned)
{
if (minerStats.Value.DateOfBan < DateTimeOffset.Now.ToUnixTimeSeconds())
{
minerStats.Value.IsBanned = false;
minerStats.Value.CurrentTotalInvalidShare = 0;
ClassLog.ConsoleWriteLog("Unban Wallet Address: " + minerStats.Key + ".", ClassLogEnumeration.IndexPoolCheckStatsLog);
}
}
else
{
if (minerStats.Value.DateOfBan >= DateTimeOffset.Now.ToUnixTimeSeconds())
{
minerStats.Value.IsBanned = true;
minerStats.Value.DateOfBan = DateTimeOffset.Now.ToUnixTimeSeconds() + MiningPoolSetting.MiningPoolMinerBanTime;
ClassLog.ConsoleWriteLog("Banned Wallet Address: " + minerStats.Key + ".", ClassLogEnumeration.IndexPoolCheckStatsLog);
}
else if (minerStats.Value.CurrentTotalInvalidShare >= MiningPoolSetting.MiningPoolMinimumInvalidShare)
{
minerStats.Value.IsBanned = true;
minerStats.Value.DateOfBan = DateTimeOffset.Now.ToUnixTimeSeconds() + MiningPoolSetting.MiningPoolMinerBanTime;
ClassLog.ConsoleWriteLog("Banned Wallet Address: " + minerStats.Key + " for too much invalid packets.", ClassLogEnumeration.IndexPoolCheckStatsLog);
}
try
{
if (!minerStats.Value.IsBanned)
{
if (minerStats.Value.ListOfMinerTcpObject.Count > 0)
{
decimal tmpTotalHashrate = 0;
bool connectedChecked = false;
for (int i = 0; i < minerStats.Value.ListOfMinerTcpObject.Count; i++)
{
if (i < minerStats.Value.ListOfMinerTcpObject.Count)
{
if (minerStats.Value.ListOfMinerTcpObject[i] != null)
{
if (minerStats.Value.ListOfMinerTcpObject[i].IsConnected && minerStats.Value.ListOfMinerTcpObject[i].IsLogged)
{
if (!connectedChecked)
{
connectedChecked = true;
totalConnectedMiner++;
}
totalConnectedWorker++;
tmpTotalHashrate += minerStats.Value.ListOfMinerTcpObject[i].CurrentHashrate;
/*if (minerStats.Value.ListOfMinerTcpObject[i].LastShareReceived +5 >= DateTimeOffset.Now.ToUnixTimeSeconds())
* {
* if (DictionaryMinerStats[minerStats.Key].TotalBan <= MiningPoolSetting.MiningPoolMaxTotalBanMiner)
* {
*
* if (minerStats.Value.ListOfMinerTcpObject[i].IsConnected && minerStats.Value.ListOfMinerTcpObject[i].IsLogged)
* {
* float score = (minerStats.Value.ListOfMinerTcpObject[i].CurrentMiningJobDifficulty / minerStats.Value.ListOfMinerTcpObject[i].CurrentHashrate) * 100;
* DictionaryMinerStats[minerStats.Key].TotalMiningScore += (long)minerStats.Value.ListOfMinerTcpObject[i].CurrentHashrate;
* }
* }
* }*/
}
}
}
}
minerStats.Value.CurrentTotalHashrate = tmpTotalHashrate;
}
else
{
minerStats.Value.CurrentTotalHashrate = 0;
}
}
else
{
minerStats.Value.CurrentTotalHashrate = 0;
}
}
catch
{
}
}
}
ClassMiningPoolGlobalStats.TotalMinerConnected = totalConnectedMiner;
ClassMiningPoolGlobalStats.TotalWorkerConnected = totalConnectedWorker;
ClassMiningPoolGlobalStats.TotalMinerHashrate = GetTotalMinerHashrate();
}
}
catch (Exception error)
{
ClassLog.ConsoleWriteLog("Check miner stats system exception error: " + error.Message, ClassLogEnumeration.IndexPoolCheckStatsErrorLog);
}
Thread.Sleep(ThreadCheckMinerStatsInterval);
}
});
ThreadCheckMinerStats.Start();
}
else
{
// Warning, the ban time should be higher than 0 seconds, the system will not be enabled.
ClassLog.ConsoleWriteLog("Warning, the ban time should be higher than 0 seconds, the system will not be enabled.", ClassLogEnumeration.IndexPoolCheckStatsErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
}
else
{
// Warning, the limit of invalid share need to be higher than 0, the system will not be enabled.
ClassLog.ConsoleWriteLog("Warning, the limit of invalid share need to be higher than 0, the system will not be enabled.", ClassLogEnumeration.IndexPoolCheckStatsErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
}
/// <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;
}
}
/// <summary>
/// Read database files of the mining pool.
/// </summary>
public static bool InitializationMiningPoolDatabases()
{
try
{
#region Read Database Miner stats
if (File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + MinerDatabaseFile)))
{
using (FileStream fs = File.Open(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + MinerDatabaseFile), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (BufferedStream bs = new BufferedStream(fs))
{
using (StreamReader sr = new StreamReader(bs))
{
string line;
while ((line = sr.ReadLine()) != null)
{
if (line.StartsWith(ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerStart))
{
string minerWalletAddress = string.Empty;
var minerLine = line.Replace(ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerStart, "");
var splitMinerLine = minerLine.Split(new[] { "|" }, StringSplitOptions.None);
foreach (var minerInfo in splitMinerLine)
{
if (minerInfo != null)
{
if (!string.IsNullOrEmpty(minerInfo))
{
if (minerInfo.StartsWith(ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerWalletAddress))
{
minerWalletAddress = minerInfo.Replace(ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerWalletAddress, "");
if (!ClassMinerStats.DictionaryMinerStats.ContainsKey(minerWalletAddress))
{
ClassMinerStats.DictionaryMinerStats.Add(minerWalletAddress, new ClassMinerStatsObject());
ClassMinerStats.DictionaryMinerTransaction.Add(minerWalletAddress, new List <string>());
}
}
if (!string.IsNullOrEmpty(minerWalletAddress))
{
if (minerInfo.StartsWith(ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalGoodShare))
{
ClassMinerStats.DictionaryMinerStats[minerWalletAddress].TotalGoodShare = long.Parse(minerInfo.Replace(ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalGoodShare, ""));
}
else if (minerInfo.StartsWith(ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalInvalidShare))
{
ClassMinerStats.DictionaryMinerStats[minerWalletAddress].TotalInvalidShare = float.Parse(minerInfo.Replace(ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalInvalidShare, ""));
}
else if (minerInfo.StartsWith(ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalMiningScore))
{
ClassMinerStats.DictionaryMinerStats[minerWalletAddress].TotalMiningScore = long.Parse(minerInfo.Replace(ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalMiningScore, ""));
}
else if (minerInfo.StartsWith(ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalBalance))
{
ClassMinerStats.DictionaryMinerStats[minerWalletAddress].TotalBalance = decimal.Parse(minerInfo.Replace(ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalBalance, "").Replace(".", ","), NumberStyles.Currency, Program.GlobalCultureInfo);
}
else if (minerInfo.StartsWith(ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerCustomMinimumPayment))
{
ClassMinerStats.DictionaryMinerStats[minerWalletAddress].CustomMinimumPayment = decimal.Parse(minerInfo.Replace(ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerCustomMinimumPayment, "").Replace(".", ","), NumberStyles.Currency, Program.GlobalCultureInfo);
}
}
}
}
}
}
}
}
}
}
}
else
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + MinerDatabaseFile)).Close();
}
#endregion
#region Read Database Pool
if (File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + PoolDatabaseFile)))
{
using (FileStream fs = File.Open(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + PoolDatabaseFile), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (BufferedStream bs = new BufferedStream(fs))
{
using (StreamReader sr = new StreamReader(bs))
{
string line;
while ((line = sr.ReadLine()) != null)
{
var splitBlockFound = line;
ClassMiningPoolGlobalStats.ListBlockFound.Add(ClassMiningPoolGlobalStats.ListBlockFound.Count, splitBlockFound);
}
}
}
}
}
else
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + PoolDatabaseFile)).Close();
}
#endregion
#region Read Database Transactions
if (File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + MinerTransactionDatabaseFile)))
{
using (FileStream fs = File.Open(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + MinerTransactionDatabaseFile), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (BufferedStream bs = new BufferedStream(fs))
{
using (StreamReader sr = new StreamReader(bs))
{
string line;
List <KeyValuePair <long, string> > ListTransactionPool = new List <KeyValuePair <long, string> >();
while ((line = sr.ReadLine()) != null)
{
if (line.StartsWith(ClassMiningPoolTransactionDatabaseEnumeration.DatabaseTransactionStart))
{
var transactionLine = line.Replace(ClassMiningPoolTransactionDatabaseEnumeration.DatabaseTransactionStart, "");
var splitTransactionLine = transactionLine.Split(new[] { "|" }, StringSplitOptions.None);
if (ClassMinerStats.DictionaryMinerTransaction.ContainsKey(splitTransactionLine[0]))
{
ClassMinerStats.DictionaryMinerTransaction[splitTransactionLine[0]].Add(splitTransactionLine[1] + "|" + splitTransactionLine[2] + "|" + splitTransactionLine[3] + "|" + splitTransactionLine[4]);
}
else
{
ClassMinerStats.DictionaryMinerTransaction.Add(splitTransactionLine[0], new List <string>()
{
splitTransactionLine[1] + "|" + splitTransactionLine[2] + "|" + splitTransactionLine[3] + "|" + splitTransactionLine[4]
});
}
if (!ClassMinerStats.DictionaryMinerStats.ContainsKey(splitTransactionLine[0]))
{
ClassMinerStats.DictionaryMinerStats.Add(splitTransactionLine[0], new ClassMinerStatsObject());
}
long dateSend = long.Parse(splitTransactionLine[4]);
decimal amountPaid = decimal.Parse(splitTransactionLine[2]);
decimal feePaid = decimal.Parse(splitTransactionLine[3]);
ClassMinerStats.DictionaryMinerStats[splitTransactionLine[0]].TotalPaid += (amountPaid + feePaid);
string transactionInfo = splitTransactionLine[1] + "|" + splitTransactionLine[2] + "|" + splitTransactionLine[3] + "|" + splitTransactionLine[4];
KeyValuePair <long, string> transactionKeyValuePair = new KeyValuePair <long, string>(dateSend, transactionInfo);
ListTransactionPool.Add(transactionKeyValuePair);
ClassMiningPoolGlobalStats.PoolTotalPaid += (amountPaid + feePaid);
}
}
if (ListTransactionPool.Count > 0)
{
ListTransactionPool = ListTransactionPool.OrderBy(x => x.Key).ToList();
foreach (var transactionPool in ListTransactionPool)
{
ClassMinerStats.DictionaryPoolTransaction.Add(ClassMinerStats.DictionaryPoolTransaction.Count, transactionPool.Value);
}
ListTransactionPool.Clear();
}
}
}
}
}
else
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + MinerTransactionDatabaseFile)).Close();
}
#endregion
}
catch (Exception error)
{
ClassLog.ConsoleWriteLog("Error on initialization of mining pool databases, exception: " + error.Message, ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
return(false);
}
return(true);
}
/// <summary>
/// Check miner trusted stats.
/// </summary>
public static void EnableCheckTrustedMinerStats()
{
if (MiningPoolSetting.MiningPoolMinimumTrustedGoodShare > 0)
{
if (MiningPoolSetting.MiningPoolMinimumIntervalTrustedShare > 0)
{
if (MiningPoolSetting.MiningPoolIntervalTrustedShare > 0)
{
ThreadCheckTrustedMinerStats = new Thread(delegate()
{
while (!Program.Exit)
{
try
{
if (DictionaryMinerStats.Count > 0)
{
foreach (var minerStats in DictionaryMinerStats)
{
if (minerStats.Value.IsBanned)
{
if (minerStats.Value.DateOfBan < DateTimeOffset.Now.ToUnixTimeSeconds())
{
minerStats.Value.IsBanned = false;
minerStats.Value.DateOfBan = 0;
minerStats.Value.IsTrusted = false; // Keep the miner not trusted at the unban moment just in case.
ClassLog.ConsoleWriteLog("Unban Wallet Address: " + minerStats.Key + ".", ClassLogEnumeration.IndexPoolCheckStatsLog);
}
else
{
minerStats.Value.IsTrusted = false; // Keep the miner not trusted just in case even if he is banned.
}
}
else
{
if (minerStats.Value.DateOfLastInvalidShare + MiningPoolSetting.MiningPoolIntervalCleanInvalidShare < DateTimeOffset.Now.ToUnixTimeSeconds())
{
minerStats.Value.CurrentTotalInvalidShare = 0;
}
if (minerStats.Value.CurrentTotalInvalidShare >= MiningPoolSetting.MiningPoolMinimumInvalidShare)
{
minerStats.Value.DateOfBan = DateTimeOffset.Now.ToUnixTimeSeconds() + MiningPoolSetting.MiningPoolMinerBanTime;
minerStats.Value.IsBanned = true;
minerStats.Value.TotalBan++;
if (minerStats.Value.TotalBan > MiningPoolSetting.MiningPoolMaxTotalBanMiner)
{
minerStats.Value.TotalMiningScore = 0;
}
minerStats.Value.IsTrusted = false;
ClassLog.ConsoleWriteLog("Banning Wallet Address: " + minerStats.Key + " for too much invalid share.", ClassLogEnumeration.IndexPoolCheckStatsLog);
}
else
{
if (minerStats.Value.IsTrusted)
{
if (minerStats.Value.DateOfTrustedShare < DateTimeOffset.Now.ToUnixTimeSeconds())
{
minerStats.Value.IsTrusted = false;
ClassLog.ConsoleWriteLog("End of trusting share for Wallet Address: " + minerStats.Key + ".", ClassLogEnumeration.IndexPoolCheckStatsLog);
}
}
else
{
if (minerStats.Value.DateOfLastGoodShare > DateTimeOffset.Now.ToUnixTimeSeconds())
{
if (minerStats.Value.CurrentTotalGoodShare > MiningPoolSetting.MiningPoolMinimumTrustedGoodShare)
{
minerStats.Value.IsTrusted = true;
minerStats.Value.DateOfTrustedShare = DateTimeOffset.Now.ToUnixTimeSeconds() + MiningPoolSetting.MiningPoolIntervalTrustedShare;
ClassLog.ConsoleWriteLog("Start trusting share for Wallet Address: " + minerStats.Key + ".", ClassLogEnumeration.IndexPoolCheckStatsLog);
}
}
else
{
minerStats.Value.CurrentTotalGoodShare = 0;
}
}
}
}
}
}
}
catch (Exception error)
{
ClassLog.ConsoleWriteLog("Check trusted miner stats system exception error: " + error.Message, ClassLogEnumeration.IndexPoolCheckStatsErrorLog);
}
Thread.Sleep(ThreadCheckMinerStatsInterval);
}
});
ThreadCheckTrustedMinerStats.Start();
}
else
{
// Warning, the interval of time of trusted share require to be higher than 0, the system will not be enabled.
ClassLog.ConsoleWriteLog("Warning, the interval of time of trusted share require to be higher than 0, the system will not be enabled.", ClassLogEnumeration.IndexPoolCheckStatsErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
}
else
{
// Warning, minimum interval of time of trusted share require to be higher than 0 second, the system will not be enabled.
ClassLog.ConsoleWriteLog("Warning, minimum interval of time of trusted share require to be higher than 0 second, the system will not be enabled.", ClassLogEnumeration.IndexPoolCheckStatsErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
}
else
{
// Warning, minimum of trusted good share require to be higher than 0, the system will not be enabled.
ClassLog.ConsoleWriteLog("Warning, minimum of trusted good share require to be higher than 0, the system will not be enabled.", ClassLogEnumeration.IndexPoolCheckStatsErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
}
/// <summary>
/// Auto save mining pools databases.
/// </summary>
public static void AutoSaveMiningPoolDatabases()
{
if (ThreadAutoSaveMiningPoolDatabases != null && (ThreadAutoSaveMiningPoolDatabases.IsAlive || ThreadAutoSaveMiningPoolDatabases != null))
{
ThreadAutoSaveMiningPoolDatabases.Abort();
GC.SuppressFinalize(ThreadAutoSaveMiningPoolDatabases);
}
ThreadAutoSaveMiningPoolDatabases = new Thread(delegate()
{
while (!Program.Exit)
{
try
{
#region Save Database Miner Stats
if (ClassMinerStats.DictionaryMinerStats.Count > 0)
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + MinerDatabaseFile)).Close();
using (var minerWriter = new StreamWriter(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + MinerDatabaseFile), true, Encoding.UTF8, 8192)
{
AutoFlush = true
})
{
foreach (var miner in ClassMinerStats.DictionaryMinerStats)
{
if (!string.IsNullOrEmpty(miner.Key))
{
string line = ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerStart +
ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerWalletAddress + miner.Key + "|" +
ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalGoodShare + miner.Value.TotalGoodShare + "|" +
ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalInvalidShare + miner.Value.TotalInvalidShare + "|" +
ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalMiningScore + miner.Value.TotalMiningScore + "|" +
ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalBalance + miner.Value.TotalBalance + "|" +
ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalPaid + miner.Value.TotalPaid + "|" +
ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerCustomMinimumPayment + miner.Value.CustomMinimumPayment;
minerWriter.WriteLine(line);
}
}
}
ClassLog.ConsoleWriteLog("Auto save miner database: " + ClassMinerStats.DictionaryMinerStats.Count + " total miners saved.", ClassLogEnumeration.IndexPoolGeneralLog);
}
#endregion
Thread.Sleep(AutoSaveMiningPoolDatabasesInterval);
#region Save Database Pool
if (ClassMiningPoolGlobalStats.ListBlockFound.Count > 0)
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + PoolDatabaseFile)).Close();
int totalBlockFound = ClassMiningPoolGlobalStats.ListBlockFound.Count;
using (var poolWriter = new StreamWriter(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + PoolDatabaseFile), true, Encoding.UTF8, 8192)
{
AutoFlush = true
})
{
for (int i = 0; i < totalBlockFound; i++)
{
if (i < totalBlockFound)
{
poolWriter.WriteLine(ClassMiningPoolGlobalStats.ListBlockFound[i]);
}
}
}
ClassLog.ConsoleWriteLog("Auto save pool database: " + totalBlockFound + " total blocks found saved.", ClassLogEnumeration.IndexPoolGeneralLog);
}
#endregion
Thread.Sleep(AutoSaveMiningPoolDatabasesInterval);
}
catch (Exception error)
{
ClassLog.ConsoleWriteLog("Auto save databases of the pool exception: " + error.Message + " retry after few seconds", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
Thread.Sleep(5000);
}
}
});
ThreadAutoSaveMiningPoolDatabases.Start();
}
/// <summary>
/// Stop auto save mining pool databases.
/// </summary>
public static void StopAutoSaveMiningPoolDatabases()
{
if (ThreadAutoSaveMiningPoolDatabases != null && (ThreadAutoSaveMiningPoolDatabases.IsAlive || ThreadAutoSaveMiningPoolDatabases != null))
{
ThreadAutoSaveMiningPoolDatabases.Abort();
GC.SuppressFinalize(ThreadAutoSaveMiningPoolDatabases);
}
#region Save Database Miner Stats
if (ClassMinerStats.DictionaryMinerStats.Count > 0)
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + MinerDatabaseFile)).Close();
using (var minerWriter = new StreamWriter(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + MinerDatabaseFile), true, Encoding.UTF8, 8192)
{
AutoFlush = true
})
{
foreach (var miner in ClassMinerStats.DictionaryMinerStats)
{
if (!string.IsNullOrEmpty(miner.Key))
{
string line = ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerStart +
ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerWalletAddress + miner.Key + "|" +
ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalGoodShare + miner.Value.TotalGoodShare + "|" +
ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalInvalidShare + miner.Value.TotalInvalidShare + "|" +
ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalMiningScore + miner.Value.TotalMiningScore + "|" +
ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalBalance + miner.Value.TotalBalance + "|" +
ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerTotalPaid + miner.Value.TotalPaid + "|" +
ClassMiningPoolMinerDatabaseEnumeration.DatabaseMinerCustomMinimumPayment + miner.Value.CustomMinimumPayment;
minerWriter.WriteLine(line);
}
}
}
ClassLog.ConsoleWriteLog("Auto save miner database: " + ClassMinerStats.DictionaryMinerStats.Count + " total miners saved.", ClassLogEnumeration.IndexPoolGeneralLog);
}
#endregion
#region Save Database Pool
if (ClassMiningPoolGlobalStats.ListBlockFound.Count > 0)
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + PoolDatabaseFile)).Close();
int totalBlockFound = ClassMiningPoolGlobalStats.ListBlockFound.Count;
using (var poolWriter = new StreamWriter(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + PoolDatabaseFile), true, Encoding.UTF8, 8192)
{
AutoFlush = true
})
{
for (int i = 0; i < totalBlockFound; i++)
{
if (i < totalBlockFound)
{
poolWriter.WriteLine(ClassMiningPoolGlobalStats.ListBlockFound[i]);
}
}
}
ClassLog.ConsoleWriteLog("Auto save pool database: " + totalBlockFound + " total blocks found saved.", ClassLogEnumeration.IndexPoolGeneralLog);
}
#endregion
#region Save Database Transactions
if (ClassMinerStats.DictionaryMinerTransaction.Count > 0)
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + MinerTransactionDatabaseFile)).Close();
using (var transactionMinerWriter = new StreamWriter(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + MinerTransactionDatabaseFile), true, Encoding.UTF8, 8192)
{
AutoFlush = true
})
{
foreach (var miner in ClassMinerStats.DictionaryMinerTransaction)
{
if (!string.IsNullOrEmpty(miner.Key))
{
if (miner.Value.Count > 0)
{
foreach (var transaction in miner.Value)
{
string line = ClassMiningPoolTransactionDatabaseEnumeration.DatabaseTransactionStart + miner.Key + "|" + transaction;
transactionMinerWriter.WriteLine(line);
}
}
}
}
}
}
#endregion
}
private static void CheckBlockchainConnection()
{
_lastPacketReceivedFromBlockchain = DateTimeOffset.Now.ToUnixTimeSeconds();
var threadCheckConnection = new Thread(async delegate()
{
while (!Program.Exit)
{
Thread.Sleep(1000);
if (!IsConnected || !classSeedNodeConnector.ReturnStatus())
{
if (ThreadListenBlockchain != null && (ThreadListenBlockchain.IsAlive || ThreadListenBlockchain != null))
{
ThreadListenBlockchain.Abort();
GC.SuppressFinalize(ThreadListenBlockchain);
}
if (ThreadAskMiningMethod != null && (ThreadAskMiningMethod.IsAlive || ThreadAskMiningMethod != null))
{
ThreadAskMiningMethod.Abort();
GC.SuppressFinalize(ThreadAskMiningMethod);
}
ClassMiningPoolGlobalStats.CurrentBlockTemplate = string.Empty;
ClassMiningPoolGlobalStats.CurrentBlockId = string.Empty;
IsConnected = false;
LoginAccepted = false;
while (!await ConnectToBlockchainAsync())
{
ClassLog.ConsoleWriteLog("Can't connect to the network, retry in 5 seconds..", ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
Thread.Sleep(5000);
}
ClassLog.ConsoleWriteLog("Connection success, generate dynamic certificate for the network.", ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
Program.Certificate = ClassUtils.GenerateCertificate();
ClassLog.ConsoleWriteLog("Certificate generate, send to the network..", ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
if (!await SendPacketToNetworkBlockchain(Program.Certificate, false))
{
ClassLog.ConsoleWriteLog("Can't send certificate, reconnect now..", ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
IsConnected = false;
}
else
{
Thread.Sleep(1000);
ClassLog.ConsoleWriteLog("Certificate sent, start to login..", ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
ListenBlockchain();
if (!await SendPacketToNetworkBlockchain(ClassConnectorSettingEnumeration.MinerLoginType + "|" + MiningPoolSetting.MiningPoolWalletAddress, true))
{
ClassLog.ConsoleWriteLog("Can't login to the network, reconnect now.", ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
IsConnected = false;
}
else
{
ClassLog.ConsoleWriteLog("Login successfully sent, waiting confirmation.. (Wait 5 seconds maximum.)", ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true);
IsConnected = true;
Thread.Sleep(ClassConnectorSetting.MaxTimeoutConnect);
if (!LoginAccepted)
{
IsConnected = false;
}
}
}
}
}
});
threadCheckConnection.Start();
}
/// <summary>
/// Handle get request received from client.
/// </summary>
/// <param name="packet"></param>
/// <returns></returns>
private async Task HandlePacketHttpAsync(string packet)
{
if (packet.Contains("|"))
{
var splitPacket = packet.Split(new[] { "|" }, StringSplitOptions.None);
switch (splitPacket[0])
{
case ClassApiEnumeration.GetPoolPaymentById:
if (int.TryParse(splitPacket[1], out var paymentId))
{
if (paymentId > 0)
{
paymentId--;
}
if (ClassMinerStats.DictionaryPoolTransaction.ContainsKey(paymentId))
{
var payment = ClassMinerStats.DictionaryPoolTransaction[paymentId].Split(new[] { "|" }, StringSplitOptions.None);
string hash = payment[0];
string amount = payment[1];
string fee = payment[2];
string timeSent = payment[3];
Dictionary <string, string> paymentContent = new Dictionary <string, string>()
{
{ "payment_id", splitPacket[1] },
{ "payment_hash", hash },
{ "payment_amount", ClassUtility.FormatMaxDecimalPlace(amount) },
{ "payment_fee", ClassUtility.FormatMaxDecimalPlace(fee) },
{ "payment_date_sent", timeSent }
};
await BuildAndSendHttpPacketAsync(string.Empty, true, paymentContent);
break;
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.IndexNotExist);
}
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.PacketError);
}
break;
case ClassApiEnumeration.GetPoolBlockById:
if (int.TryParse(splitPacket[1], out var blockId))
{
if (blockId > 0)
{
blockId--;
}
if (ClassMiningPoolGlobalStats.ListBlockFound.ContainsKey(blockId))
{
var blockFound = ClassMiningPoolGlobalStats.ListBlockFound[blockId];
var splitBlock = blockFound.Split(new[] { "|" }, StringSplitOptions.None);
var blockResult = await ClassRemoteApi.GetBlockInformation(splitBlock[0]);
if (blockResult != null)
{
try
{
JObject jObjectBlock = JObject.Parse(blockResult);
if (jObjectBlock.ContainsKey("result")) // Usually showed has not exist when the remote node don't have finish to sync blocks mined.
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.IndexNotExist);
}
else
{
await BuildAndSendHttpPacketAsync(blockResult, false, null, true); // Send already jsonfyed request.
}
}
catch (Exception error)
{
ClassLog.ConsoleWriteLog("Pool API - Remote Node HTTP API packet exception: " + error.Message + " packet received: " + blockResult, ClassLogEnumeration.IndexPoolApiErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog);
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.PacketError);
}
}
else
{
ClassLog.ConsoleWriteLog("Pool API - Warning, your Remote Node HTTP API seems to not respond !", ClassLogEnumeration.IndexPoolApiErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.PacketError);
}
break;
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.IndexNotExist);
}
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.PacketError);
}
break;
case ClassApiEnumeration.GetWalletPaymentById:
if (splitPacket.Length > 1)
{
if (ClassMinerStats.DictionaryMinerStats.ContainsKey(splitPacket[1]))
{
if (ClassMinerStats.DictionaryMinerTransaction.ContainsKey(splitPacket[1]))
{
if (int.TryParse(splitPacket[2], out var walletPaymentId))
{
if (walletPaymentId > 0)
{
walletPaymentId--;
}
if (ClassMinerStats.DictionaryMinerTransaction[splitPacket[1]].Count > walletPaymentId)
{
var paymentSplit = ClassMinerStats.DictionaryMinerTransaction[splitPacket[1]][walletPaymentId].Split(new[] { "|" }, StringSplitOptions.None);
string transactionHash = paymentSplit[0];
string transactionAmount = paymentSplit[1];
string transactionFee = paymentSplit[2];
string transactionDateSent = paymentSplit[3];
Dictionary <string, string> paymentContent = new Dictionary <string, string>()
{
{ "payment_hash", transactionHash },
{ "payment_amount", ClassUtility.FormatMaxDecimalPlace(transactionAmount) },
{ "payment_fee", ClassUtility.FormatMaxDecimalPlace(transactionFee) },
{ "payment_date_sent", transactionDateSent }
};
await BuildAndSendHttpPacketAsync(string.Empty, true, paymentContent);
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.WalletPaymentIndexNotExist);
}
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.PacketError);
}
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.WalletNoPaymentExist);
}
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.WalletNotExist);
}
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.PacketError);
}
break;
case ClassApiEnumeration.GetWalletStats:
if (splitPacket.Length > 1)
{
if (ClassMinerStats.DictionaryMinerStats.ContainsKey(splitPacket[1]))
{
int totalPayment = 0;
long totalGoodShare = 0;
float totalInvalidShare = 0;
string totalBalance = "0";
string totalPaid = "0";
decimal totalHashrate = 0;
decimal totalMiningScore = 0;
decimal totalMiningScorePool = 0;
decimal customMinimumPayment = 0;
long lastShareReceived = 0;
if (ClassMinerStats.DictionaryMinerTransaction.ContainsKey(splitPacket[1]))
{
totalPayment = ClassMinerStats.DictionaryMinerTransaction[splitPacket[1]].Count;
}
totalGoodShare = ClassMinerStats.DictionaryMinerStats[splitPacket[1]].TotalGoodShare;
totalInvalidShare = ClassMinerStats.DictionaryMinerStats[splitPacket[1]].TotalInvalidShare;
totalBalance = ClassMinerStats.DictionaryMinerStats[splitPacket[1]].TotalBalance.ToString("F" + ClassConnectorSetting.MaxDecimalPlace);
totalPaid = ClassMinerStats.DictionaryMinerStats[splitPacket[1]].TotalPaid.ToString("F" + ClassConnectorSetting.MaxDecimalPlace);
totalHashrate = ClassMinerStats.DictionaryMinerStats[splitPacket[1]].CurrentTotalHashrate;
totalMiningScore = ClassMinerStats.DictionaryMinerStats[splitPacket[1]].TotalMiningScore;
customMinimumPayment = ClassMinerStats.DictionaryMinerStats[splitPacket[1]].CustomMinimumPayment;
lastShareReceived = ClassMinerStats.DictionaryMinerStats[splitPacket[1]].DateOfLastGoodShare;
foreach (var minerStats in ClassMinerStats.DictionaryMinerStats)
{
if (minerStats.Value.TotalBan <= MiningPoolSetting.MiningPoolMaxTotalBanMiner)
{
if (minerStats.Value.TotalMiningScore > 0)
{
totalMiningScorePool += minerStats.Value.TotalMiningScore;
}
}
}
Dictionary <string, string> minerStatsContent = new Dictionary <string, string>()
{
{ "wallet_address", splitPacket[1] },
{ "wallet_total_hashrate", "" + totalHashrate },
{ "wallet_total_good_share", "" + totalGoodShare },
{ "wallet_total_invalid_share", "" + totalInvalidShare },
{ "wallet_total_balance", totalBalance },
{ "wallet_total_paid", totalPaid },
{ "wallet_total_payment", "" + totalPayment },
{ "wallet_total_mining_score", totalMiningScore.ToString("F0") },
{ "wallet_total_pool_mining_score", totalMiningScorePool.ToString("F0") },
{ "wallet_custom_minimum_payment", "" + customMinimumPayment },
{ "wallet_last_share_received", "" + lastShareReceived }
};
await BuildAndSendHttpPacketAsync(string.Empty, true, minerStatsContent);
break;
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.WalletNotExist);
}
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.PacketError);
}
break;
case ClassApiEnumeration.SetWalletCustomMinimumPayment:
if (splitPacket.Length > 2)
{
if (ClassMinerStats.DictionaryMinerStats.ContainsKey(splitPacket[1]))
{
var customMinimumPaymentString = ClassUtility.FormatMaxDecimalPlace(splitPacket[2].Replace(".", ",")).Replace(".", ",");
if (decimal.TryParse(customMinimumPaymentString, NumberStyles.Currency, Program.GlobalCultureInfo, out var customMinimumPayment))
{
if (customMinimumPayment >= MiningPoolSetting.MiningPoolMinimumBalancePayment)
{
ClassMinerStats.DictionaryMinerStats[splitPacket[1]].CustomMinimumPayment = customMinimumPayment;
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.CustomMinimumPaymentChanged);
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.CustomMinimumPaymentTooLowest);
}
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.CustomMinimumPaymentNotValid);
}
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.WalletNotExist);
}
}
else
{
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.PacketError);
}
break;
default:
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.PacketNotExist);
break;
}
}
else
{
switch (packet)
{
case ClassApiEnumeration.GetPoolStats:
decimal networkHashrate = 0;
string networkInformation = await ClassRemoteApi.GetNetworkInformation();
if (networkInformation != null)
{
var networkInformationObject = JObject.Parse(networkInformation);
networkHashrate = decimal.Parse(networkInformationObject["coin_network_hashrate"].ToString());
string lastBlockFoundDate = "0";
if (ClassMiningPoolGlobalStats.ListBlockFound.Count > 0)
{
lastBlockFoundDate = ClassMiningPoolGlobalStats.ListBlockFound[ClassMiningPoolGlobalStats.ListBlockFound.Count - 1].Split(new[] { "|" }, StringSplitOptions.None)[1];
}
var lastBlockFound = int.Parse(ClassMiningPoolGlobalStats.CurrentBlockId) - 1;
string blockHash = string.Empty;
string blockTimestampFound = "0";
string blockReward = "0";
if (ClassApi.DictionaryBlockHashCache.ContainsKey(lastBlockFound))
{
blockHash = ClassApi.DictionaryBlockHashCache[lastBlockFound];
blockTimestampFound = ClassApi.DictionaryBlockDateFoundCache[lastBlockFound];
blockReward = ClassApi.DictionaryBlockRewardCache[lastBlockFound];
}
else
{
var blockResult = await ClassRemoteApi.GetBlockInformation("" + lastBlockFound);
if (blockResult != null)
{
JObject blockJson = JObject.Parse(blockResult);
blockHash = blockJson["block_hash"].ToString();
blockTimestampFound = blockJson["block_timestamp_found"].ToString();
blockReward = blockJson["block_reward"].ToString();
try
{
ClassApi.DictionaryBlockHashCache.Add(lastBlockFound, blockHash);
}
catch
{
}
try
{
ClassApi.DictionaryBlockDateFoundCache.Add(lastBlockFound, blockTimestampFound);
}
catch
{
}
try
{
ClassApi.DictionaryBlockRewardCache.Add(lastBlockFound, blockReward);
}
catch
{
}
}
else
{
ClassLog.ConsoleWriteLog("Pool API - Warning, your Remote Node HTTP API seems to not respond !", ClassLogEnumeration.IndexPoolApiErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.PacketError);
}
}
string miningPortInfo = string.Empty;
if (MiningPoolSetting.MiningPoolMiningPort.Count > 0)
{
int counter = 0;
foreach (var miningPort in MiningPoolSetting.MiningPoolMiningPort)
{
counter++;
if (counter < MiningPoolSetting.MiningPoolMiningPort.Count)
{
miningPortInfo += miningPort.Key + "|" + miningPort.Value + ";"; // Mining port + mining difficulty;
}
else
{
miningPortInfo += miningPort.Key + "|" + miningPort.Value; // Mining port + mining difficulty;
}
}
}
Dictionary <string, string> poolStatsContent = new Dictionary <string, string>()
{
{ "pool_hashrate", ClassMiningPoolGlobalStats.TotalMinerHashrate.ToString() },
{ "pool_total_miner_connected", ClassMiningPoolGlobalStats.TotalMinerConnected.ToString() },
{ "pool_total_worker_connected", ClassMiningPoolGlobalStats.TotalWorkerConnected.ToString() },
{ "pool_total_payment", ClassMinerStats.DictionaryPoolTransaction.Count.ToString() },
{ "pool_total_paid", ClassMiningPoolGlobalStats.PoolTotalPaid.ToString("F" + ClassConnectorSetting.MaxDecimalPlace) },
{ "pool_total_block_found", ClassMiningPoolGlobalStats.ListBlockFound.Count.ToString() },
{ "pool_fee", MiningPoolSetting.MiningPoolFee.ToString() },
{ "pool_last_block_found_date", lastBlockFoundDate },
{ "pool_mining_port_and_difficulty", miningPortInfo },
{ "pool_minimum_payment", "" + MiningPoolSetting.MiningPoolMinimumBalancePayment },
{ "network_height", ClassMiningPoolGlobalStats.CurrentBlockId },
{ "network_difficulty", ClassMiningPoolGlobalStats.CurrentBlockDifficulty },
{ "network_hashrate", networkHashrate.ToString() },
{ "network_last_block_hash", blockHash },
{ "network_last_block_found_timestamp", blockTimestampFound },
{ "network_last_block_reward", blockReward }
};
await BuildAndSendHttpPacketAsync(string.Empty, true, poolStatsContent);
}
else
{
ClassLog.ConsoleWriteLog("Pool API - Warning, your Remote Node HTTP API seems to not respond !", ClassLogEnumeration.IndexPoolApiErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.PacketError);
}
break;
default:
await BuildAndSendHttpPacketAsync(ClassApiEnumeration.PacketNotExist);
break;
}
}
}
/// <summary>
/// Proceed mining score done by miners
/// </summary>
public static async void ProceedMiningScoreRewardAsync(string blockId)
{
if (PoolOnProceedBlockReward)
{
ClassLog.ConsoleWriteLog("Waiting proceed previous block reward before to proceed reward block id: " + blockId + "..", ClassLogEnumeration.IndexPoolPaymentLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
}
while (PoolOnProceedBlockReward)
{
await Task.Delay(100);
if (Program.Exit)
{
break;
}
}
PoolOnProceedBlockReward = true;
if (PoolOnSendingTransaction)
{
ClassLog.ConsoleWriteLog("Waiting end of proceed payments before to proceed reward block id: " + blockId + "..", ClassLogEnumeration.IndexPoolPaymentLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
}
while (PoolOnSendingTransaction)
{
await Task.Delay(100);
if (Program.Exit)
{
break;
}
}
ClassLog.ConsoleWriteLog("Proceed block reward from block found: " + blockId, ClassLogEnumeration.IndexPoolPaymentLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
decimal blockReward = ClassConnectorSetting.ConstantBlockReward;
if (MiningPoolSetting.MiningPoolFee > 0)
{
decimal poolFeeAmount = (blockReward * MiningPoolSetting.MiningPoolFee) / 100;
blockReward -= poolFeeAmount;
ClassLog.ConsoleWriteLog("Pool fee of " + MiningPoolSetting.MiningPoolFee + "% take " + poolFeeAmount + " " + ClassConnectorSetting.CoinNameMin + " from total block reward of " + ClassConnectorSetting.ConstantBlockReward + " " + ClassConnectorSetting.CoinName, ClassLogEnumeration.IndexPoolPaymentLog);
}
ClassLog.ConsoleWriteLog("Proceed block reward from Block ID: " + blockId + " with a block reward calculated with pool of " + MiningPoolSetting.MiningPoolFee + "% -> result: " + blockReward + " " + ClassConnectorSetting.CoinName, ClassLogEnumeration.IndexPoolPaymentLog);
await Task.Delay(1000);
decimal totalMiningScore = 0;
foreach (var minerStats in ClassMinerStats.DictionaryMinerStats)
{
if (minerStats.Value.TotalMiningScore > 0)
{
if (minerStats.Value.TotalBan <= MiningPoolSetting.MiningPoolMaxTotalBanMiner)
{
totalMiningScore += minerStats.Value.TotalMiningScore;
}
}
}
ClassLog.ConsoleWriteLog("Total mining score done by miners on Block ID: " + blockId + " " + totalMiningScore, ClassLogEnumeration.IndexPoolPaymentLog);
foreach (var minerStats in ClassMinerStats.DictionaryMinerStats)
{
if (minerStats.Value.TotalBan <= MiningPoolSetting.MiningPoolMaxTotalBanMiner)
{
if (minerStats.Value.TotalMiningScore > 0)
{
decimal pourcentageOfReward = (minerStats.Value.TotalMiningScore / totalMiningScore) * 100;
decimal minerReward = ((blockReward * pourcentageOfReward) / 100);
ClassLog.ConsoleWriteLog("Miner " + minerStats.Key + " receive " + pourcentageOfReward + "% of block ID: " + blockId + " amount: " + minerReward + " " + ClassConnectorSetting.CoinNameMin, ClassLogEnumeration.IndexPoolPaymentLog);
minerStats.Value.TotalBalance += minerReward;
ClassMinerStats.DictionaryMinerStats[minerStats.Key].TotalMiningScore = 0;
}
}
}
PoolOnProceedBlockReward = false;
ClassLog.ConsoleWriteLog("Proceed block reward from block found: " + blockId + " done.", ClassLogEnumeration.IndexPoolPaymentLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true);
}
/// <summary>
/// Start to listen incoming client.
/// </summary>
/// <returns></returns>
public async Task StartHandleClientHttpAsync()
{
var isWhitelisted = true;
if (ClassFilteringMiner.CheckMinerIsBannedByIP(_ip))
{
isWhitelisted = false;
}
int totalWhile = 0;
if (isWhitelisted)
{
await Task.Run(() => MaxKeepAliveFunctionAsync()).ConfigureAwait(false);
try
{
while (_clientStatus)
{
try
{
using (CancellationTokenSource cancellationPacket = new CancellationTokenSource(1000))
{
using (NetworkStream clientHttpReader = new NetworkStream(_client.Client))
{
using (BufferedStream bufferedStreamNetwork = new BufferedStream(clientHttpReader, ClassConnectorSetting.MaxNetworkPacketSize))
{
byte[] buffer = new byte[ClassConnectorSetting.MaxNetworkPacketSize];
int received = await bufferedStreamNetwork.ReadAsync(buffer, 0, buffer.Length);
if (received > 0)
{
string packet = Encoding.UTF8.GetString(buffer, 0, received);
try
{
if (!GetAndCheckForwardedIp(packet))
{
break;
}
}
catch
{
}
packet = ClassUtility.GetStringBetween(packet, "GET /", "HTTP");
packet = packet.Replace("%7C", "|"); // Translate special character |
packet = packet.Replace(" ", ""); // Remove empty,space characters
ClassLog.ConsoleWriteLog("HTTP API - packet received from IP: " + _ip + " - " + packet, ClassLogEnumeration.IndexPoolApiLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog);
await HandlePacketHttpAsync(packet);
break;
}
else
{
totalWhile++;
}
if (totalWhile >= 8)
{
break;
}
}
}
}
}
catch (Exception error)
{
ClassLog.ConsoleWriteLog("HTTP API - exception error: " + error.Message, ClassLogEnumeration.IndexPoolApiErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog);
break;
}
}
}
catch
{
}
}
CloseClientConnection();
}
/// <summary>
/// Enable auto payment system.
/// </summary>
public static void EnableAutoPaymentSystem()
{
if (ThreadAutoPaymentSystem != null && (ThreadAutoPaymentSystem.IsAlive || ThreadAutoPaymentSystem != null))
{
ThreadAutoPaymentSystem.Abort();
GC.SuppressFinalize(ThreadAutoPaymentSystem);
}
if (MiningPoolSetting.MiningPoolIntervalPayment > 0)
{
if (MiningPoolSetting.MiningPoolMinimumBalancePayment > 0)
{
if (MiningPoolSetting.MiningPoolFeeTransactionPayment > 0)
{
if (MiningPoolSetting.MiningPoolFeeTransactionPayment >= ClassConnectorSetting.MinimumWalletTransactionFee)
{
ThreadAutoPaymentSystem = new Thread(async delegate()
{
while (!Program.Exit)
{
try
{
if (!PoolOnProceedBlockReward)
{
PoolOnSendingTransaction = true;
if (await ClassRpcWallet.GetCurrentBalance())
{
ClassLog.ConsoleWriteLog("Start to proceed payments.", ClassLogEnumeration.IndexPoolPaymentLog);
if (ClassMinerStats.DictionaryMinerStats.Count > 0)
{
foreach (var minerStats in ClassMinerStats.DictionaryMinerStats)
{
if (minerStats.Value.TotalBan <= MiningPoolSetting.MiningPoolMaxTotalBanMiner)
{
if (minerStats.Value.TotalBalance >= MiningPoolSetting.MiningPoolMinimumBalancePayment)
{
if (minerStats.Value.CustomMinimumPayment == 0 || minerStats.Value.TotalBalance >= minerStats.Value.CustomMinimumPayment) // Make payment if the miner don't have select a custom minimum payment or when his current balance reach his custom minimum payment set.
{
if (await ClassRpcWallet.GetCurrentBalance())
{
if (minerStats.Value.TotalBalance <= ClassMiningPoolGlobalStats.PoolCurrentBalance)
{
decimal minersBalanceBase = minerStats.Value.TotalBalance;
decimal minersBalance = minerStats.Value.TotalBalance;
minersBalance = minersBalance - MiningPoolSetting.MiningPoolFeeTransactionPayment;
ClassLog.ConsoleWriteLog("Attempt to send transaction of " + minersBalance + " " + ClassConnectorSetting.CoinNameMin + " to miner " + minerStats.Key, ClassLogEnumeration.IndexPoolPaymentLog);
long dateSent = ClassUtility.GetCurrentDateInSecond();
string resultPayment = await ClassRpcWallet.SendTransaction(minerStats.Key, minersBalance);
if (resultPayment != string.Empty)
{
var resultPaymentSplit = resultPayment.Split(new[] { "|" }, StringSplitOptions.None);
switch (resultPaymentSplit[0])
{
case ClassRpcWalletCommand.SendTokenTransactionConfirmed:
minerStats.Value.TotalBalance -= minersBalanceBase;
minerStats.Value.TotalPaid += minersBalanceBase;
ClassMiningPoolGlobalStats.PoolTotalPaid += minersBalanceBase;
ClassMinerStats.InsertTransactionPayment(minerStats.Key, resultPaymentSplit[1], minersBalance, dateSent);
ClassLog.ConsoleWriteLog("Transaction sent to miner " + minerStats.Key + " is confirmed, transaction hash: " + resultPaymentSplit[1], ClassLogEnumeration.IndexPoolPaymentLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true);
break;
default:
ClassLog.ConsoleWriteLog("Transaction sent to miner " + minerStats.Key + " is not confirmed, response received: " + resultPaymentSplit[0], ClassLogEnumeration.IndexPoolPaymentLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
break;
}
}
else
{
ClassLog.ConsoleWriteLog("No response from RPC Wallet to proceed payment to miner: " + minerStats.Key, ClassLogEnumeration.IndexPoolPaymentErrorLog);
}
}
else
{
ClassLog.ConsoleWriteLog("Can't proceed payment to miner: " + minerStats.Key + ", not enought coin on the pool wallet. | " + minerStats.Value.TotalBalance + "/" + ClassMiningPoolGlobalStats.PoolCurrentBalance, ClassLogEnumeration.IndexPoolPaymentErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
}
else
{
ClassLog.ConsoleWriteLog("Can't proceed payment to miner: " + minerStats.Key + ", cannot get current pool balance.", ClassLogEnumeration.IndexPoolPaymentErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
}
}
}
else
{
ClassLog.ConsoleWriteLog("Can't proceed payment to miner: " + minerStats.Key + ", the miner have reach too much ban.", ClassLogEnumeration.IndexPoolPaymentErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog);
}
}
}
ClassLog.ConsoleWriteLog("End to proceed payments.", ClassLogEnumeration.IndexPoolPaymentLog);
}
else
{
ClassLog.ConsoleWriteLog("Can't proceed payment, cannot get current pool balance.", ClassLogEnumeration.IndexPoolPaymentErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
PoolOnSendingTransaction = false;
}
else
{
ClassLog.ConsoleWriteLog("Pool currently on proceed block reward, payments will are launch after.", ClassLogEnumeration.IndexPoolPaymentLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true);
}
}
catch (Exception error)
{
PoolOnSendingTransaction = false;
ClassLog.ConsoleWriteLog("Proceed payments exception error: " + error.Message, ClassLogEnumeration.IndexPoolPaymentErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
Thread.Sleep(MiningPoolSetting.MiningPoolIntervalPayment * 1000);
}
});
ThreadAutoPaymentSystem.Start();
}
else
{
ClassLog.ConsoleWriteLog("Warning, the transaction " + ClassConnectorSetting.CoinNameMin + " fee is less than the minimum accepted of: " + ClassConnectorSetting.MinimumWalletTransactionFee + ", the payment system will not be enabled.", ClassLogEnumeration.IndexPoolPaymentErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
}
else
{
ClassLog.ConsoleWriteLog("Warning, the transaction " + ClassConnectorSetting.CoinNameMin + " fee is less or equals of 0, the payment system will not be enabled.", ClassLogEnumeration.IndexPoolPaymentErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
}
else
{
ClassLog.ConsoleWriteLog("Warning, the minimum of " + ClassConnectorSetting.CoinNameMin + " to reach for proceed payment, is less or equals of 0, the payment system will not be enabled.", ClassLogEnumeration.IndexPoolPaymentErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
}
else
{
ClassLog.ConsoleWriteLog("Warning, the interval of payment is less or equals of 0 second, the payment system will not be enabled.", ClassLogEnumeration.IndexPoolPaymentErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true);
}
}