/// <summary>
/// Save each transaction into cache
/// </summary>
/// <param name="walletAddress"></param>
public static void SaveWalletCache(string walletAddress, string transaction)
{
if (!string.IsNullOrEmpty(walletAddress))
{
walletAddress += "ANONYMITY";
if (ListTransaction.Count > 0 && _inClearCache == false)
{
if (Directory.Exists(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletTransactionCacheDirectory)) == false)
{
Directory.CreateDirectory(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletTransactionCacheDirectory));
}
if (Directory.Exists(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletTransactionCacheDirectory +
walletAddress)) == false)
{
Directory.CreateDirectory(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletTransactionCacheDirectory +
walletAddress));
}
if (!File.Exists(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletTransactionCacheDirectory +
walletAddress +
"\\" + WalletTransactionCacheFileExtension)))
{
File.Create(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletTransactionCacheDirectory + walletAddress + "\\" + WalletTransactionCacheFileExtension)).Close();
}
try
{
using (var transactionFile = new StreamWriter(ClassUtility.ConvertPath(
System.AppDomain.CurrentDomain.BaseDirectory + WalletTransactionCacheDirectory +
walletAddress +
"\\" + WalletTransactionCacheFileExtension), true))
{
transactionFile.WriteLine(transaction);
}
}
catch
{
// ignored
}
}
}
}
private static async ValueTask <IReadOnlyList <Class> > CreateClasses(GameServiceClient client)
{
ConsoleUtility.WriteLine("Creating classes");
var classes = new[]
{
new Class {
Name = "Covert", ImagePath = "https://ajpzgq.dm.files.1drv.com/y4mXvnkneQVHhJCM2Thk1pl4Cx5baH-wl7L5-6otZ7lOBj6dmZxjWzitVFLHbvRGTWhoq36lDHHFGBf96betGJQ8J5Mjc5agn37dMu4Mih-dgeYZDTYu-eLudNDy-Ntq-U0ryaGtmFeS6vCo0nxA7_yba_6XhsfqpVq_tsKm7QWGIeeUaD6zFy38QRISl5F-og5aOAE5iRFdmlHfJcJOYQJng?width=70&height=71&cropmode=none"
},
new Class {
Name = "Strength", ImagePath = "https://nfekpa.dm.files.1drv.com/y4mr6RzK0c1UnrqMTzd2hKAPVazy8uSmlsD_PgJ3TMh4x49A1qmggJEPYzDnXztatHkz-JFdQP6C7E6M-NwJ3cHlu6D8h6Fv-6P2XIlFH1JAqKhPWscJVqO1zVXeyh176wUliaSrVIspBFdsaxVkZQE2synKMSCt-2-yoxZXCKJhU9KP6amVgqOXYE3vWPtOWm74KTHcMwWNXntrzpmsaeqFw?width=73&height=71&cropmode=none"
},
new Class {
Name = "Tech", ImagePath = "https://z8wx3g.dm.files.1drv.com/y4mktwH5rgCyBejw6Ib8MMp7-eiZMBEC_xnF3jmW8Jdbt-sqPSoDVIyvmWFNGLbGgENZn9I_mdRPBCF7eB5RPy5hFtl5lELNBrqBkgRUjXH1AnHfyCLlV2XTY_QV_KMqN8wc8_RgSIstZSuY291fLIcL8zisH9rDaewt3NknxopBfqbxD908Cn8HXdl8oG1IIYwQkVhfHW03jD7UlZ-wIhAHg?width=58&height=71&cropmode=none"
},
new Class {
Name = "Ranged", ImagePath = "https://z8wx3g.dm.files.1drv.com/y4mktwH5rgCyBejw6Ib8MMp7-eiZMBEC_xnF3jmW8Jdbt-sqPSoDVIyvmWFNGLbGgENZn9I_mdRPBCF7eB5RPy5hFtl5lELNBrqBkgRUjXH1AnHfyCLlV2XTY_QV_KMqN8wc8_RgSIstZSuY291fLIcL8zisH9rDaewt3NknxopBfqbxD908Cn8HXdl8oG1IIYwQkVhfHW03jD7UlZ-wIhAHg?width=58&height=71&cropmode=none"
},
new Class {
Name = "Instinct", ImagePath = "https://mdximq.dm.files.1drv.com/y4mT3HV9mjGjRn_aO8yNjtoj_GnsZhZwdXMT6Jt3to6Xsm3TlKphA0iLI6zIjCAm3bBrmubC97eY4HK6p6JL8mZ_XGGk_wZo7gJphFcLNjqyT3TNcRV1rPlu33sEatJIYwWvRL5oAU1rF0RcpMR7G1M7as7VhaFnomuAteXI0ypCDZ3-tG72q-bAnwJu__GeDnc0KVFM03eiT4Yt6GBUq99fg?width=66&height=71&cropmode=none"
},
};
var existingClasses = await ClassUtility.GetClassesAsync(client, null);
if (existingClasses.Any())
{
return(existingClasses);
}
var request = new CreateClassesRequest();
request.Classes.AddRange(classes);
request.CreateOptions.Add(CreateOptions.ErrorOnDuplicates);
var reply = await client.CreateClassesAsync(request);
if (reply.Status.Code != 200)
{
ConsoleUtility.WriteLine($"Failed to create classes: '{reply.Status.Message}'");
}
return(reply.Classes);
}
/// <summary>
/// Load block in cache.
/// </summary>
/// <returns></returns>
public static void LoadBlockchainCache()
{
if (ListBlock != null)
{
ListBlock.Clear();
}
else
{
ListBlock = new List <string>();
}
if (Directory.Exists(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory + "\\")))
{
if (
File.Exists(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory +
"/blockchain" + WalletBlockCacheFileExtension)))
{
int counter = 0;
using (FileStream fs = File.Open(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory +
"/blockchain" + WalletBlockCacheFileExtension), 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)
{
ListBlock.Add(line);
counter++;
}
}
}
}
else
{
if (Directory.Exists(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory)) == false)
{
Directory.CreateDirectory(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory));
}
Directory.CreateDirectory(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory));
}
}
/// <summary>
/// Save peer list.
/// </summary>
public static void SavePeerList()
{
try
{
File.Create(AppDomain.CurrentDomain.BaseDirectory + PeerFileName).Close();
using (var writer =
new StreamWriter(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + PeerFileName)))
{
foreach (var peer in PeerList.ToArray())
{
var peerData = JsonConvert.SerializeObject(peer.Value);
writer.WriteLine(peerData);
}
}
}
catch
{
}
}
/// <summary>
/// Remove by contact name, because they should are unique.
/// </summary>
/// <param name="name"></param>
public static void RemoveContact(string name)
{
if (ListContactWallet.ContainsKey(name.ToLower()))
{
ListContactWallet.Remove(name.ToLower());
}
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + ContactFileName))
.Close(); // Create and close the file for don't make in busy permissions.
foreach (var contact in ListContactWallet)
{
using (var writerContact =
new StreamWriter(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + ContactFileName),
true))
{
writerContact.WriteLine(contact.Value.Item1 + "|" + contact.Value.Item2);
}
}
}
/// <summary>
/// Clear each block into cache.
/// </summary>
public static bool RemoveWalletBlockCache()
{
try
{
if (Directory.Exists(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory + "\\")))
{
File.Delete(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory +
"/blockchain." + WalletBlockCacheFileExtension));
Directory.Delete(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory + "\\"), true);
Directory.CreateDirectory(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory));
}
}
catch
{
//
}
ListBlock.Clear();
return(true);
}
/// <summary>
/// Save each block into cache
/// </summary>
/// <param name="block"></param>
public static async Task SaveWalletBlockCache(string block)
{
if (Directory.Exists(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory)) == false)
{
Directory.CreateDirectory(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory));
}
if (File.Exists(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory +
"/blockchain" + WalletBlockCacheFileExtension)) == false)
{
try
{
File.Create(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory +
"/blockchain" + WalletBlockCacheFileExtension)).Close();
using (var transactionFile = new StreamWriter(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory +
"/blockchain" + WalletBlockCacheFileExtension), true))
{
await transactionFile.WriteAsync(block + "\n").ConfigureAwait(false);
}
}
catch
{
// ignored
}
}
else
{
try
{
using (var transactionFile = new StreamWriter(ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory +
"/blockchain" + WalletBlockCacheFileExtension), true))
{
await transactionFile.WriteAsync(block + "\n").ConfigureAwait(false);
}
}
catch
{
//
}
}
}
/// <summary>
/// Create the log directory and log files if they not exist.
/// </summary>
private static bool LogInitializationFile()
{
if (Directory.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogDirectory)) == false)
{
Directory.CreateDirectory(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogDirectory));
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogGeneral)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogGeneral)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogWalletUpdater)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogWalletUpdater)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogApi)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogApi)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogSync)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogSync)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogRemoteNodeSync)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogRemoteNodeSync)).Close();
return(false);
}
return(true);
}
public MainWindow()
{
InitializeComponent();
KeyDown += VplControl.VplControl_KeyDown;
KeyUp += VplControl.VplControl_KeyUp;
VplControl.ExternalNodeTypes.AddRange(
ClassUtility.GetTypesInNamespace(Assembly.GetExecutingAssembly(), "TUM.CMS.VplControl.Test.Nodes")
.ToList());
VplControl.ExternalNodeTypes.AddRange(
ClassUtility.GetTypesInNamespace(Assembly.GetExecutingAssembly(), "TUM.CMS.VplControl.Watch3D.Nodes")
.ToList());
VplControl.ExternalNodeTypes.Add(typeof(ScriptingNode));
VplControl.ExternalNodeTypes.Add(typeof(Watch3DNode));
VplControl.NodeTypeMode = NodeTypeModes.All;
// VplPropertyGrid.SelectedObject = VplControl;
}
/// <summary>
/// Insert a new contact to the list and save the database file.
/// </summary>
/// <param name="name"></param>
/// <param name="walletAddress"></param>
/// <returns></returns>
public static bool InsertContact(string name, string walletAddress)
{
if (ListContactWallet.ContainsKey(name.ToLower()))
{
#if DEBUG
Log.WriteLine("Contact name: " + name + " already exist.");
#endif
return(false);
}
foreach (var contactList in ListContactWallet)
{
if (contactList.Value.Item2.ToLower() == walletAddress.ToLower())
{
#if DEBUG
Log.WriteLine("Contact wallet address: " + walletAddress + " already exist.");
#endif
return(false);
}
if (contactList.Value.Item1.ToLower() == name.ToLower())
{
#if DEBUG
Log.WriteLine("Contact wallet address: " + walletAddress + " already exist.");
#endif
return(false);
}
}
ListContactWallet.Add(name.ToLower(), new Tuple <string, string>(name, walletAddress));
using (var writerContact =
new StreamWriter(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + ContactFileName),
true))
{
writerContact.WriteLine(name + "|" + walletAddress);
}
return(true);
}
/// <summary>
/// Catch unexpected exception and them to a log file.
/// </summary>
private static void EnableCatchUnexpectedException()
{
AppDomain.CurrentDomain.UnhandledException += delegate(object sender, UnhandledExceptionEventArgs args2)
{
var filePath = ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + UnexpectedExceptionFile);
var exception = (Exception)args2.ExceptionObject;
using (var writer = new StreamWriter(filePath, true))
{
writer.WriteLine("Message :" + exception.Message + "<br/>" + Environment.NewLine +
"StackTrace :" +
exception.StackTrace +
"" + Environment.NewLine + "Date :" + DateTime.Now);
writer.WriteLine(Environment.NewLine +
"-----------------------------------------------------------------------------" +
Environment.NewLine);
}
Trace.TraceError(exception.StackTrace);
Console.WriteLine("Unexpected error catched, check the error file: " + ClassUtility.ConvertPath(System.AppDomain.CurrentDomain.BaseDirectory + UnexpectedExceptionFile));
Environment.Exit(1);
};
}
/// <summary>
/// Load setting file of the wallet gui.
/// </summary>
public static bool LoadSetting()
{
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + _WalletSettingFile)))
{
SaveSetting();
return(true); // This is the first start of the wallet gui.
}
string jsonSetting = string.Empty;
using (var reader =
new StreamReader(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + _WalletSettingFile)))
{
string line;
while ((line = reader.ReadLine()) != null)
{
jsonSetting += line;
}
}
try
{
var walletSettingJsonObject = JsonConvert.DeserializeObject <ClassWalletSettingJson>(jsonSetting);
ClassTranslation.CurrentLanguage = walletSettingJsonObject.wallet_current_language;
Program.WalletXiropht.WalletSyncHostname = walletSettingJsonObject.wallet_sync_manual_host;
Program.WalletXiropht.WalletSyncMode = (ClassWalletSyncMode)walletSettingJsonObject.wallet_sync_mode;
Program.WalletXiropht.WalletEnableProxyMode = walletSettingJsonObject.enable_proxy_mode;
ClassPeerList.PeerMaxBanTime = walletSettingJsonObject.peer_max_ban_time;
ClassPeerList.PeerMaxDisconnect = walletSettingJsonObject.peer_max_disconnect;
ClassPeerList.PeerEnableTrustSystem = walletSettingJsonObject.enable_peer_trust_system;
}
catch
{
return(false);
}
return(true);
}
/// <summary>
/// Generates the 'count by' method.
/// </summary>
/// <param name="file">The file.</param>
/// <param name="propertyMaps">The property maps.</param>
/// <param name="returnedClassMap">The returned class map.</param>
public override void GenerateCountBy(StreamWriter file, IList <IPropertyMap> propertyMaps, IClassMap returnedClassMap)
{
ArrayList allColumns = returnedClassMap.GetTableMap().ColumnMaps;
// build the 'where' statement
bool first = true;
StringBuilder whereQuery = new StringBuilder(16 * propertyMaps.Count);
foreach (IPropertyMap propertyMap in propertyMaps)
{
if (!first)
{
whereQuery.Append(" AND ");
}
whereQuery
.Append('`')
.Append(propertyMap.GetColumnMap().Name)
.Append("`='\" + m_state.EscapeString(")
.Append(ClassUtility.GetParamName(propertyMap))
.Append(".ToString()) + \"'");
first = false;
}
string entityClassName = EntityGenerator.GetTypeName(returnedClassMap);
string sqlCommand = "SELECT count(*)"
+ " FROM `" + returnedClassMap.GetTableMap().Name + "`"
+ " WHERE " + whereQuery.ToString();
// create an array and store results
file.WriteLine();
file.WriteLine(" return (long) m_state.ExecuteScalar(");
file.WriteLine(" \""+ sqlCommand + "\");");
file.WriteLine();
}
/// <summary>
/// Check password validity
/// </summary>
private bool CheckPasswordValidity()
{
if (textBoxPassword.Text.Length >= ClassConnectorSetting.WalletMinPasswordLength)
{
if (ClassUtility.CheckPassword(textBoxPassword.Text))
{
MethodInvoker invoke = () => pictureBoxPasswordStatus.BackgroundImage = Resources.valid;
BeginInvoke(invoke);
return(true);
}
else
{
MethodInvoker invoke = () => pictureBoxPasswordStatus.BackgroundImage = Resources.error;
BeginInvoke(invoke);
}
}
else
{
MethodInvoker invoke = () => pictureBoxPasswordStatus.BackgroundImage = Resources.error;
BeginInvoke(invoke);
}
return(false);
}
public SelectionNode(VplControl hostCanvas) : base(hostCanvas)
{
searchTextBox = new SearchTextBox();
searchTextBox.OnSearch += searchTextBox_OnSearch;
var tempTypeList = new List <Type>();
AddControlToNode(searchTextBox);
listBox.DisplayMemberPath = "Name";
listBox.MaxHeight = 140;
AddControlToNode(listBox);
if (hostCanvas.NodesFilterted)
{
foreach (var item in hostCanvas.ExternalNodeTypes)
{
if (item.Namespace.Contains(hostCanvas.NodesFilterName))
{
tempTypeList.Add(item);
}
}
}
else
{
switch (hostCanvas.NodeTypeMode)
{
case NodeTypeModes.OnlyInternalTypes:
tempTypeList.AddRange(
ClassUtility.GetTypesInNamespace(Assembly.GetExecutingAssembly(), "TUM.CMS.VplControl.Nodes")
.ToList());
break;
case NodeTypeModes.OnlyExternalTypes:
tempTypeList.AddRange(hostCanvas.ExternalNodeTypes);
break;
case NodeTypeModes.All:
tempTypeList.AddRange(
ClassUtility.GetTypesInNamespace(Assembly.GetExecutingAssembly(), "TUM.CMS.VplControl.Nodes")
.ToList());
tempTypeList.AddRange(hostCanvas.ExternalNodeTypes);
break;
}
}
tempTypeList = tempTypeList.OrderBy(x => x.Name).ToList();
foreach (var type in tempTypeList.Where(type => !type.IsAbstract))
{
if (type.Name.Contains('<') || type.Name.Contains("ComboboxItem"))
{
}
else
{
typeList.Add(type);
}
}
listBox.ItemsSource = typeList;
searchTextBox.PreviewKeyDown += searchTextBox_KeyDown;
listBox.PreviewMouseLeftButtonUp += listBox_PreviewMouseLeftButtonUp;
listBox.SelectionMode = SelectionMode.Single;
Border.MouseLeave += SelectionNode_MouseLeave;
MouseEnter += SelectionNode_MouseEnter;
}
/// <summary>
/// Load RPC Database file.
/// </summary>
/// <returns></returns>
public static bool LoadRpcDatabaseFile()
{
RpcDatabaseContent = new Dictionary <string, ClassWalletObject>();
try
{
if (File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + RpcDatabaseFile)))
{
using (FileStream fs = File.Open(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + RpcDatabaseFile), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (BufferedStream bs = new BufferedStream(fs))
{
using (StreamReader sr = new StreamReader(bs))
{
string line;
int lineRead = 0;
while ((line = sr.ReadLine()) != null)
{
lineRead++;
if (line.StartsWith(ClassRpcDatabaseEnumeration.DatabaseWalletStartLine))
{
string walletData = line.Replace(ClassRpcDatabaseEnumeration.DatabaseWalletStartLine, "");
walletData = ClassAlgo.GetDecryptedResultManual(ClassAlgoEnumeration.Rijndael, walletData, RpcDatabasePassword, ClassWalletNetworkSetting.KeySize);
if (walletData != ClassAlgoErrorEnumeration.AlgoError)
{
var splitWalletData = walletData.Split(new[] { "|" }, StringSplitOptions.None);
var walletAddress = splitWalletData[0];
if (!RpcDatabaseContent.ContainsKey(walletAddress))
{
var walletPublicKey = splitWalletData[1];
var walletPrivateKey = splitWalletData[2];
var walletPinCode = splitWalletData[3];
var walletPassword = splitWalletData[4];
var walletObject = new ClassWalletObject(walletAddress, walletPublicKey, walletPassword, walletPrivateKey, walletPinCode, walletData);
if (!RpcDatabaseContent.ContainsKey(walletAddress))
{
RpcDatabaseContent.Add(walletAddress, walletObject);
}
}
}
else
{
ClassConsole.ConsoleWriteLine("Decrypt database of wallets failed at line: " + lineRead);
return(false);
}
}
}
}
}
}
}
else
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + RpcDatabaseFile)).Close();
}
}
catch
{
return(false);
}
RpcDatabaseStreamWriter = new StreamWriter(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + RpcDatabaseFile), true, Encoding.UTF8, 8192)
{
AutoFlush = true
};
return(true);
}
/// <summary>
/// Force to save whole databases of wallets.
/// </summary>
public static async Task <bool> SaveWholeRpcWalletDatabaseFile()
{
while (InSave)
{
await Task.Delay(100);
}
InSave = true;
bool success = false;
while (!success)
{
try
{
try
{
RpcDatabaseStreamWriter?.Close();
RpcDatabaseStreamWriter?.Dispose();
}
catch
{
}
File.Copy(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + RpcDatabaseFile), ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + RpcDatabaseFileBackup + "-" + DateTimeOffset.Now.ToUnixTimeMilliseconds())); // Backup wallet database just in case.
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + RpcDatabaseFile)).Close();
RpcDatabaseStreamWriter = new StreamWriter(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + RpcDatabaseFile), true, Encoding.UTF8, 8192)
{
AutoFlush = true
};
foreach (var wallet in RpcDatabaseContent)
{
string encryptedWallet = ClassAlgo.GetEncryptedResultManual(ClassAlgoEnumeration.Rijndael, wallet.Value.GetWalletAddress() + "|" + wallet.Value.GetWalletPublicKey() + "|" + wallet.Value.GetWalletPrivateKey() + "|" + wallet.Value.GetWalletPinCode() + "|" + wallet.Value.GetWalletPassword(), RpcDatabasePassword, ClassWalletNetworkSetting.KeySize);
RpcDatabaseStreamWriter.WriteLine(ClassRpcDatabaseEnumeration.DatabaseWalletStartLine + encryptedWallet);
}
success = true;
}
catch
{
RpcDatabaseStreamWriter = new StreamWriter(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + RpcDatabaseFile), true, Encoding.UTF8, 8192)
{
AutoFlush = true
};
}
}
InSave = false;
return(true);
}
/// <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>
/// 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
}
/// <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>
/// 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);
}
}
/// <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>
/// Load block in cache.
/// </summary>
/// <returns></returns>
public static void LoadBlockchainCache()
{
if (ListBlock != null)
{
ListBlock.Clear();
ListBlockIndex.Clear();
}
else
{
ListBlock = new Dictionary <string, ClassBlockObject>();
ListBlockIndex = new Dictionary <int, string>();
}
OnLoad = true;
try
{
Task.Factory.StartNew(() =>
{
if (Directory.Exists(
ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + WalletBlockCacheDirectory +
"\\")))
{
if (
File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory +
WalletBlockCacheDirectory +
"/blockchain" + WalletBlockCacheFileExtension)))
{
var counter = 0;
using (var fs =
File.Open(
ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory +
WalletBlockCacheDirectory + "/blockchain" +
WalletBlockCacheFileExtension), FileMode.Open,
FileAccess.Read, FileShare.ReadWrite))
using (var bs = new BufferedStream(fs))
using (var sr = new StreamReader(bs))
{
string line;
while ((line = sr.ReadLine()) != null)
{
var blockLine = line.Split(new[] { "#" }, StringSplitOptions.None);
if (!ListBlock.ContainsKey(blockLine[1]))
{
var blockObject = new ClassBlockObject
{
BlockHeight = blockLine[0],
BlockHash = blockLine[1],
BlockTransactionHash = blockLine[2],
BlockTimestampCreate = blockLine[3],
BlockTimestampFound = blockLine[4],
BlockDifficulty = blockLine[5],
BlockReward = blockLine[6]
};
ListBlock.Add(blockLine[1], blockObject);
ListBlockIndex.Add(ListBlockIndex.Count, blockLine[1]);
counter++;
}
#if DEBUG
else
{
Log.WriteLine("Duplicate block line: " + line);
}
#endif
}
}
}
}
else
{
if (Directory.Exists(
ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory +
WalletBlockCacheDirectory)) ==
false)
{
Directory.CreateDirectory(
ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory +
WalletBlockCacheDirectory));
}
Directory.CreateDirectory(
ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory +
WalletBlockCacheDirectory));
}
OnLoad = false;
Program.WalletXiropht.ClassWalletObject.TotalBlockInSync = ListBlock.Count;
}, Program.WalletXiropht.WalletCancellationToken.Token,
TaskCreationOptions.DenyChildAttach, TaskScheduler.Current).ConfigureAwait(false);
}
catch
{
Program.WalletXiropht.ClassWalletObject.TotalBlockInSync = 0;
ListBlock.Clear();
ListBlockIndex.Clear();
OnLoad = false;
}
}
/// <summary>
/// Insert new math combinaison
/// </summary>
/// <param name="combinaison"></param>
/// <param name="idThread"></param>
public bool InsertMathCombinaison(string combinaison, int idThread)
{
if (_lastDateRamCounted < DateTimeOffset.Now.ToUnixTimeSeconds())
{
if (Environment.OSVersion.Platform == PlatformID.Unix)
{
var availbleRam = long.Parse(ClassUtility.RunCommandLineMemoryAvailable());
_lastDateRamCounted = DateTimeOffset.Now.ToUnixTimeSeconds() + RamCounterInterval;
if (availbleRam <= _ramLimitInMb)
{
return(true);
}
}
else
{
float availbleRam = _ramCounter.NextValue();
_lastDateRamCounted = DateTimeOffset.Now.ToUnixTimeSeconds() + RamCounterInterval;
if (availbleRam <= _ramLimitInMb)
{
return(true);
}
}
}
try
{
if (MiningListCache.Count > 0)
{
bool inserted = false;
for (int i = 0; i < MiningListCache.Count; i++)
{
if (!inserted)
{
if (i < MiningListCache.Count)
{
if (MiningListCache[i].Count < MaxMathCombinaisonPerCache)
{
if (MiningListCache[i].ContainsKey(combinaison))
{
return(false);
}
MiningListCache[i].Add(combinaison, idThread);
inserted = true;
}
}
}
}
if (!inserted)
{
MiningListCache.Add(new Dictionary <string, int>());
if (!MiningListCache[MiningListCache.Count - 1].ContainsKey(combinaison))
{
MiningListCache[MiningListCache.Count - 1].Add(combinaison, idThread);
return(true);
}
}
}
else
{
MiningListCache.Add(new Dictionary <string, int>());
if (!MiningListCache[0].ContainsKey(combinaison))
{
MiningListCache[0].Add(combinaison, idThread);
return(true);
}
return(false);
}
}
catch
{
return(false);
}
return(true);
}
public MainWindow()
{
InitializeComponent();
KeyDown += VplControl.VplControl_KeyDown;
KeyUp += VplControl.VplControl_KeyUp;
VplControl.ExternalNodeTypes.AddRange(
ClassUtility.GetTypesInNamespace(Assembly.GetExecutingAssembly(), "TUM.CMS.VplControl.Test.Nodes")
.ToList());
VplControl.ExternalNodeTypes.AddRange(
ClassUtility.GetTypesInNamespace(Assembly.GetAssembly(typeof(Watch3DNode)), "TUM.CMS.VplControl.Watch3D.Nodes")
.ToList());
VplControl.ExternalNodeTypes.AddRange(
ClassUtility.GetTypesInNamespace(Assembly.GetAssembly(typeof(EnergyCalculatorNode)), "TUM.CMS.VplControl.Energy.Nodes")
.ToList());
VplControl.ExternalNodeTypes.AddRange(
ClassUtility.GetTypesInNamespace(Assembly.GetAssembly(typeof(IfcMapsNode)), "TUM.CMS.VplControl.IFC.Nodes")
.ToList());
VplControl.ExternalNodeTypes.Add(typeof(ScriptingNode));
// VplControl.ExternalNodeTypes.Add(typeof(Watch3DNode));
VplControl.NodeTypeMode = NodeTypeModes.All;
//VplControl.NodeTypeMode = NodeTypeModes.OnlyInternalTypes;
VplControl.NodesFilterted = false;
var groupNamespaces = VplControl.ExternalNodeTypes.GroupBy(u => u.Namespace).Select(grp => grp.ToList()).ToList();
Separator separator = new Separator();
Nodes.Items.Add(separator);
foreach (var namespaceItem in groupNamespaces)
{
var namespaceNameList = namespaceItem[0].Namespace.Split('.');
var namespaceName = namespaceNameList[3];
if (namespaceNameList[3] == "")
{
namespaceName = namespaceNameList[2];
}
MenuItem namespaceMenuItem = new MenuItem();
namespaceMenuItem.Header = namespaceName;
namespaceMenuItem.Name = namespaceName;
Nodes.Items.Add(namespaceMenuItem);
foreach (var item in namespaceItem)
{
if (!item.Name.Contains("<"))
{
MenuItem tempItem1 = new MenuItem();
tempItem1.Header = item.Name;
tempItem1.Click += NodeItem_Click;
namespaceMenuItem.Items.Add(tempItem1);
}
}
}
foreach (var namespaceItem in groupNamespaces)
{
var namespaceNameList = namespaceItem[0].Namespace.Split('.');
var namespaceName = namespaceNameList[3];
if (namespaceNameList[3] == "")
{
namespaceName = namespaceNameList[2];
}
MenuItem namespaceMenuItem = new MenuItem();
namespaceMenuItem.Header = namespaceName;
namespaceMenuItem.Click += ChangeNodesFilter_Click;
SelectShownNodes.Items.Add(namespaceMenuItem);
}
Separator separator1 = new Separator();
SelectShownNodes.Items.Add(separator1);
MenuItem namespaceMenuItem1 = new MenuItem();
namespaceMenuItem1.Header = "All";
namespaceMenuItem1.Click += ChangeNodesFilter_Click;
SelectShownNodes.Items.Add(namespaceMenuItem1);
string dirPath = Directory.GetParent(Directory.GetCurrentDirectory()) + "\\Templates\\";
string[] files = Directory.GetFiles(dirPath);
foreach (var file in files)
{
FileInfo info = new FileInfo(file);
FileAttributes attributes = info.Attributes;
if (info.Extension.ToUpper() == ".VPLXML")
{
MenuItem menuItem = new MenuItem();
menuItem.Header = Path.GetFileNameWithoutExtension(info.Name);
menuItem.Click += OpenTemplateNode;
NodesTemplate.Items.Add(menuItem);
}
}
}
/// <summary>
/// Generates the 'find' method.
/// </summary>
/// <param name="file">The file.</param>
/// <param name="classMap">The class map.</param>
public override void GenerateFind(StreamWriter file, IClassMap classMap)
{
ArrayList primaryColumns = classMap.GetTableMap().GetPrimaryKeyColumnMaps();
StringBuilder whereQuery = new StringBuilder();
StringBuilder findParams = new StringBuilder();
bool first = true;
foreach (IColumnMap primColumn in primaryColumns)
{
IPropertyMap propertyMap = classMap.GetPropertyMapForColumnMap(primColumn);
if (!first)
{
whereQuery.Append(", ");
findParams.Append(", ");
}
whereQuery
.Append('`')
.Append(primColumn.Name)
.Append("`='\" + m_state.EscapeString(")
.Append(ClassUtility.GetParamName(propertyMap))
.Append(".ToString()) + \"'");
string paramName = ClassUtility.GetParamName(propertyMap);
string paramType = ClassUtility.ConvertColumnTypeToCsType(primColumn.DataType);
findParams.Append(paramType + " " + paramName);
first = false;
}
string entityClassName = EntityGenerator.GetTypeName(classMap);
string sqlCommand = "SELECT \" + c_rowFields + \""
+ " FROM `" + classMap.GetTableMap().Name + "`"
+ " WHERE " + whereQuery.ToString();
file.WriteLine(" public virtual "+ entityClassName + " Find(" + findParams.ToString() + ")");
file.WriteLine(" {");
file.WriteLine(" "+ entityClassName + " result = new " + entityClassName + "();");
file.WriteLine(" string command = \""+ sqlCommand + "\";");
file.WriteLine();
file.WriteLine(" m_state.ExecuteQuery(");
file.WriteLine(" command,");
file.WriteLine(" CommandBehavior.SingleRow,");
file.WriteLine(" delegate(MySqlDataReader reader)");
file.WriteLine(" {");
file.WriteLine(" if (!reader.Read())");
file.WriteLine(" {");
file.WriteLine(" result = null;");
file.WriteLine(" }");
file.WriteLine(" else");
file.WriteLine(" {");
file.WriteLine(" FillEntityWithRow(ref result, reader);");
file.WriteLine(" }");
file.WriteLine(" }");
file.WriteLine(" );");
file.WriteLine();
file.WriteLine(" return result;");
file.WriteLine(" }");
file.WriteLine();
}
/// <summary>
/// Create the log directory and log files if they not exist.
/// </summary>
private static bool LogInitializationFile()
{
if (Directory.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogDirectory)) == false)
{
Directory.CreateDirectory(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogDirectory));
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolGeneralError)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolGeneralError)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolGeneral)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolGeneral)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolFilteringError)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolFilteringError)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolFiltering)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolFiltering)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolMinerCheckStatsError)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolMinerCheckStatsError)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolMinerCheckStats)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolMinerCheckStats)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolPaymentError)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolPaymentError)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolPayment)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolPayment)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolWalletError)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolWalletError)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolWallet)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolWallet)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolApiError)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolApiError)).Close();
return(false);
}
if (!File.Exists(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolApi)))
{
File.Create(ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + LogPoolApi)).Close();
return(false);
}
return(true);
}
/// <summary>
/// Enable console command line.
/// </summary>
public static void EnableConsoleCommandLine()
{
ThreadConsoleCommandLine = new Thread(async delegate()
{
while (!Program.Exit)
{
string commandLine = Console.ReadLine();
if (Program.Exit)
{
break;
}
try
{
var splitCommandLine = commandLine.Split(new char[0], StringSplitOptions.None);
switch (splitCommandLine[0])
{
case ClassConsoleCommandLineEnumeration.CommandLineHelp:
ClassConsole.ConsoleWriteLine(ClassConsoleCommandLineEnumeration.CommandLineHelp + " -> show list of command lines.", ClassConsoleColorEnumeration.IndexConsoleMagentaLog, Program.LogLevel);
ClassConsole.ConsoleWriteLine(ClassConsoleCommandLineEnumeration.CommandLineCreateWallet + " -> permit to create a new wallet manualy.", ClassConsoleColorEnumeration.IndexConsoleMagentaLog, Program.LogLevel);
ClassConsole.ConsoleWriteLine(ClassConsoleCommandLineEnumeration.CommandLineRestoreWallet + " -> permit to restore a wallet manualy. Syntax: " + ClassConsoleCommandLineEnumeration.CommandLineRestoreWallet + " wallet_address", ClassConsoleColorEnumeration.IndexConsoleMagentaLog, Program.LogLevel);
ClassConsole.ConsoleWriteLine(ClassConsoleCommandLineEnumeration.CommandLineSaveWallet + " -> permit to save manually the database of wallets.", ClassConsoleColorEnumeration.IndexConsoleMagentaLog, Program.LogLevel);
ClassConsole.ConsoleWriteLine(ClassConsoleCommandLineEnumeration.CommandLineLogLevel + " -> change log level. Max log level: " + ClassConsole.MaxLogLevel, ClassConsoleColorEnumeration.IndexConsoleMagentaLog, Program.LogLevel);
break;
case ClassConsoleCommandLineEnumeration.CommandLineCreateWallet:
using (var walletCreatorObject = new ClassWalletCreator())
{
new Thread(async delegate()
{
if (!await walletCreatorObject.StartWalletConnectionAsync(ClassWalletPhase.Create, ClassUtility.MakeRandomWalletPassword()))
{
ClassConsole.ConsoleWriteLine("RPC Wallet cannot create a new wallet.", ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel);
}
}).Start();
while (walletCreatorObject.WalletCreateResult == ClassWalletCreatorEnumeration.WalletCreatorPending)
{
Thread.Sleep(100);
}
switch (walletCreatorObject.WalletCreateResult)
{
case ClassWalletCreatorEnumeration.WalletCreatorError:
ClassConsole.ConsoleWriteLine("RPC Wallet cannot create a new wallet.", ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel);
break;
case ClassWalletCreatorEnumeration.WalletCreatorSuccess:
ClassConsole.ConsoleWriteLine("RPC Wallet successfully create a new wallet.", ClassConsoleColorEnumeration.IndexConsoleGreenLog, Program.LogLevel);
ClassConsole.ConsoleWriteLine("New wallet address generated: " + walletCreatorObject.WalletAddressResult, ClassConsoleColorEnumeration.IndexConsoleBlueLog, Program.LogLevel);
break;
}
}
break;
case ClassConsoleCommandLineEnumeration.CommandLineRestoreWallet:
if (splitCommandLine.Length < 2)
{
ClassConsole.ConsoleWriteLine("Please, put the wallet address to restore.", ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel);
}
else
{
if (ClassRpcDatabase.RpcDatabaseContent.ContainsKey(splitCommandLine[1]))
{
using (var walletCreatorObject = new ClassWalletCreator())
{
new Thread(async delegate()
{
if (!await walletCreatorObject.StartWalletConnectionAsync(ClassWalletPhase.Restore, ClassUtility.MakeRandomWalletPassword(), ClassRpcDatabase.RpcDatabaseContent[splitCommandLine[1]].GetWalletPrivateKey(), splitCommandLine[1]))
{
ClassConsole.ConsoleWriteLine("RPC Wallet cannot restore your wallet: " + splitCommandLine[1], ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel);
}
}).Start();
while (walletCreatorObject.WalletCreateResult == ClassWalletCreatorEnumeration.WalletCreatorPending)
{
Thread.Sleep(100);
}
switch (walletCreatorObject.WalletCreateResult)
{
case ClassWalletCreatorEnumeration.WalletCreatorError:
ClassConsole.ConsoleWriteLine("RPC Wallet cannot restore a wallet: " + splitCommandLine[1], ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel);
break;
case ClassWalletCreatorEnumeration.WalletCreatorSuccess:
ClassConsole.ConsoleWriteLine("RPC Wallet successfully restore wallet: " + splitCommandLine[1], ClassConsoleColorEnumeration.IndexConsoleGreenLog, Program.LogLevel);
ClassConsole.ConsoleWriteLine("RPC Wallet execute save the database of wallets..", ClassConsoleColorEnumeration.IndexConsoleYellowLog, Program.LogLevel);
if (await ClassRpcDatabase.SaveWholeRpcWalletDatabaseFile())
{
ClassConsole.ConsoleWriteLine("RPC Wallet save of the database of wallets done successfully.", ClassConsoleColorEnumeration.IndexConsoleGreenLog, Program.LogLevel);
}
else
{
ClassConsole.ConsoleWriteLine("RPC Wallet save of the database of wallets failed, please retry by command line: " + ClassConsoleCommandLineEnumeration.CommandLineSaveWallet, ClassConsoleColorEnumeration.IndexConsoleGreenLog, Program.LogLevel);
}
break;
}
}
}
else
{
ClassConsole.ConsoleWriteLine("Please, put a valid wallet address stored on the database of your rpc wallet to restore. " + splitCommandLine[1] + " not exist.", ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel);
}
}
break;
case ClassConsoleCommandLineEnumeration.CommandLineSaveWallet:
if (await ClassRpcDatabase.SaveWholeRpcWalletDatabaseFile())
{
ClassConsole.ConsoleWriteLine("RPC Wallet save of the database of wallets done successfully.", ClassConsoleColorEnumeration.IndexConsoleGreenLog, Program.LogLevel);
}
else
{
ClassConsole.ConsoleWriteLine("RPC Wallet save of the database of wallets failed, please retry by command line: " + ClassConsoleCommandLineEnumeration.CommandLineSaveWallet, ClassConsoleColorEnumeration.IndexConsoleGreenLog, Program.LogLevel);
}
break;
case ClassConsoleCommandLineEnumeration.CommandLineLogLevel:
if (splitCommandLine.Length > 1)
{
if (int.TryParse(splitCommandLine[1], out var logLevel))
{
if (logLevel < 0)
{
logLevel = 0;
}
else
{
if (logLevel > ClassConsole.MaxLogLevel)
{
logLevel = ClassConsole.MaxLogLevel;
}
}
ClassConsole.ConsoleWriteLine("New log level " + Program.LogLevel + " -> " + logLevel, ClassConsoleColorEnumeration.IndexConsoleMagentaLog, Program.LogLevel);
Program.LogLevel = logLevel;
}
}
else
{
ClassConsole.ConsoleWriteLine("Please select a log level.", ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel);
}
break;
case ClassConsoleCommandLineEnumeration.CommandLineExit:
Program.Exit = true;
ClassConsole.ConsoleWriteLine("Closing RPC Wallet..", ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel);
ClassApi.StopApiHttpServer();
if (ClassRpcSetting.RpcWalletEnableRemoteNodeSync)
{
ClassWalletUpdater.DisableAutoUpdateWallet();
}
ClassRemoteSync.StopRpcWalletToSync();
if (Program.ThreadRemoteNodeSync != null && (Program.ThreadRemoteNodeSync.IsAlive || Program.ThreadRemoteNodeSync != null))
{
Program.ThreadRemoteNodeSync.Abort();
GC.SuppressFinalize(Program.ThreadRemoteNodeSync);
}
ClassConsole.ConsoleWriteLine("Waiting end of save RPC Wallet Database..", ClassConsoleColorEnumeration.IndexConsoleYellowLog, Program.LogLevel);
while (ClassRpcDatabase.InSave)
{
Thread.Sleep(100);
}
ClassConsole.ConsoleWriteLine("Waiting end of save RPC Wallet Sync Database..", ClassConsoleColorEnumeration.IndexConsoleYellowLog, Program.LogLevel);
while (ClassSyncDatabase.InSave)
{
Thread.Sleep(100);
}
ClassLog.StopLogSystem();
ClassConsole.ConsoleWriteLine("RPC Wallet is successfully stopped, press ENTER to exit.", ClassConsoleColorEnumeration.IndexConsoleBlueLog, Program.LogLevel);
Console.ReadLine();
Process.GetCurrentProcess().Kill();
break;
}
if (Program.Exit)
{
break;
}
}
catch (Exception error)
{
ClassConsole.ConsoleWriteLine("Error command line exception: " + error.Message, ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel);
ClassConsole.ConsoleWriteLine("For get help use command line " + ClassConsoleCommandLineEnumeration.CommandLineHelp, ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel);
}
}
});
ThreadConsoleCommandLine.Start();
}
/// <summary>
/// Load transMethodInvoker in cache.
/// </summary>
/// <param name="walletAddress"></param>
/// <returns></returns>
public static void LoadWalletCache(string walletAddress)
{
if (ListTransaction != null)
{
ListTransaction.Clear();
}
else
{
ListTransaction = new Dictionary <string, ClassWalletTransactionObject>();
}
if (!string.IsNullOrEmpty(walletAddress))
{
OnLoad = true;
try
{
Task.Factory.StartNew(() =>
{
if (Directory.Exists(
ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory +
WalletTransMethodInvokerCacheDirectory + walletAddress +
"\\")))
{
if (File.Exists(ClassUtility.ConvertPath(
AppDomain.CurrentDomain.BaseDirectory + WalletTransMethodInvokerCacheDirectory +
walletAddress + "\\" + WalletTransMethodInvokerCacheFileExtension)))
{
byte[] AesKeyIv = null;
byte[] AesSalt = null;
using (var password = new PasswordDeriveBytes(
Program.WalletXiropht.ClassWalletObject.WalletConnect.WalletAddress +
Program.WalletXiropht.ClassWalletObject.WalletConnect.WalletKey,
ClassUtils.GetByteArrayFromString(ClassUtils.FromHex(
(Program.WalletXiropht.ClassWalletObject.WalletConnect.WalletAddress +
Program.WalletXiropht.ClassWalletObject.WalletConnect.WalletKey)
.Substring(0, 8)))))
{
AesKeyIv = password.GetBytes(
ClassConnectorSetting.MAJOR_UPDATE_1_SECURITY_CERTIFICATE_SIZE / 8);
AesSalt = password.GetBytes(16);
}
var listTransactionEncrypted = new List <string>();
using (var fs = File.Open(
ClassUtility.ConvertPath(AppDomain.CurrentDomain.BaseDirectory +
WalletTransMethodInvokerCacheDirectory +
walletAddress +
"\\" + WalletTransMethodInvokerCacheFileExtension),
FileMode.Open, FileAccess.Read, FileShare.Read))
using (var bs = new BufferedStream(fs))
using (var sr = new StreamReader(bs))
{
string line;
while ((line = sr.ReadLine()) != null)
{
listTransactionEncrypted.Add(line);
}
}
if (listTransactionEncrypted.Count > 0)
{
var line = 0;
foreach (var transactionEncrypted in listTransactionEncrypted)
{
line++;
var walletTransactionDecrypted =
ClassAlgo.GetDecryptedResult(ClassAlgoEnumeration.Rijndael,
transactionEncrypted, ClassWalletNetworkSetting.KeySize, AesKeyIv,
AesSalt);
if (walletTransactionDecrypted != ClassAlgoErrorEnumeration.AlgoError)
{
var splitTransaction =
walletTransactionDecrypted.Split(new[] { "#" },
StringSplitOptions.None);
if (!ListTransaction.ContainsKey(splitTransaction[1]))
{
var splitBlockchainHeight = splitTransaction[7]
.Split(new[] { "~" }, StringSplitOptions.None);
var transactionObject = new ClassWalletTransactionObject
{
TransactionType = splitTransaction[0],
TransactionHash = splitTransaction[1],
TransactionWalletAddress = splitTransaction[2],
TransactionAmount =
decimal.Parse(
splitTransaction[3].ToString(Program.GlobalCultureInfo),
NumberStyles.Currency, Program.GlobalCultureInfo),
TransactionFee = decimal.Parse(
splitTransaction[4].ToString(Program.GlobalCultureInfo),
NumberStyles.Currency, Program.GlobalCultureInfo),
TransactionTimestampSend = long.Parse(splitTransaction[5]),
TransactionTimestampRecv = long.Parse(splitTransaction[6]),
TransactionBlockchainHeight =
splitBlockchainHeight[0].Replace("{", "")
};
ListTransaction.Add(splitTransaction[1], transactionObject);
Program.WalletXiropht.UpdateLabelSyncInformation(
"On load transaction database - total transactions loaded and decrypted: " +
(ListTransaction.Count + ClassWalletTransactionAnonymityCache
.ListTransaction.Count));
}
#if DEBUG
else
{
Log.WriteLine("Duplicate anonymous transaction: " + walletTransactionDecrypted);
}
#endif
}
#if DEBUG
else
{
Log.WriteLine("Wrong transaction at line: " + line);
}
#endif
}
}
listTransactionEncrypted.Clear();
Program.WalletXiropht.ClassWalletObject.TotalTransactionInSync =
ListTransaction.Count;
AesKeyIv = null;
AesSalt = null;
}
else
{
File.Create(ClassUtility.ConvertPath(
AppDomain.CurrentDomain.BaseDirectory + WalletTransMethodInvokerCacheDirectory +
walletAddress + "\\" + WalletTransMethodInvokerCacheFileExtension)).Close();
}
}
else
{
if (Directory.Exists(ClassUtility.ConvertPath(
AppDomain.CurrentDomain.BaseDirectory +
WalletTransMethodInvokerCacheDirectory)) ==
false)
{
Directory.CreateDirectory(ClassUtility.ConvertPath(
AppDomain.CurrentDomain.BaseDirectory +
WalletTransMethodInvokerCacheDirectory));
}
Directory.CreateDirectory(ClassUtility.ConvertPath(
AppDomain.CurrentDomain.BaseDirectory + WalletTransMethodInvokerCacheDirectory +
walletAddress));
}
Program.WalletXiropht.ClassWalletObject.TotalTransactionInSync = ListTransaction.Count;
OnLoad = false;
}, Program.WalletXiropht.WalletCancellationToken.Token,
TaskCreationOptions.DenyChildAttach, TaskScheduler.Current).ConfigureAwait(false);
}
catch
{
Program.WalletXiropht.ClassWalletObject.TotalTransactionInSync = 0;
ListTransaction.Clear();
OnLoad = false;
}
}
}
/// <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();
}
