public async Task SaveAsync(string trackerFolderPath)
{
await Saving.WaitAsync().ConfigureAwait(false);
try
{
if (TrackedScriptPubKeys.Count > 0 || TrackedTransactions.Count > 0 || MerkleChain.Count > 0)
{
Directory.CreateDirectory(trackerFolderPath);
}
if (TrackedScriptPubKeys.Count > 0)
{
File.WriteAllLines(
Path.Combine(trackerFolderPath, TrackedScriptPubKeysFileName),
TrackedScriptPubKeys.Select(x => x.ToString()));
}
if (TrackedTransactions.Count > 0)
{
File.WriteAllLines(
Path.Combine(trackerFolderPath, TrackedTransactionsFileName),
TrackedTransactions
.Select(x => $"{x.Transaction.ToHex()}:{x.Height}"));
}
if (MerkleChain.Count > 0)
{
var path = Path.Combine(trackerFolderPath, MerkleChainFileName);
if (File.Exists(path))
{
const string backupName = MerkleChainFileName + "_backup";
var backupPath = Path.Combine(trackerFolderPath, backupName);
File.Copy(path, backupPath, overwrite: true);
File.Delete(path);
}
using (FileStream stream = File.OpenWrite(path))
{
var toFile = MerkleChain.First().ToBytes();
await stream.WriteAsync(toFile, 0, toFile.Length).ConfigureAwait(false);
foreach (var block in MerkleChain.Skip(1))
{
await stream.WriteAsync(blockSep, 0, blockSep.Length).ConfigureAwait(false);
var blockBytes = block.ToBytes();
await stream.WriteAsync(blockBytes, 0, blockBytes.Length).ConfigureAwait(false);
}
}
}
}
finally
{
Saving.Release();
}
}
/// <param name="scriptPubKey">BitcoinAddress.ScriptPubKey</param>
/// <param name="searchFullBlockBuffer">If true: it look for transactions in the buffered full blocks in memory</param>
public void Track(Script scriptPubKey, bool searchFullBlockBuffer = false)
{
TrackedScriptPubKeys.Add(scriptPubKey);
foreach (var block in FullBlockBuffer)
{
TrackIfFindRelatedTransactions(scriptPubKey, block.Key, block.Value);
}
}
public async Task LoadAsync(string trackerFolderPath)
{
await Saving.WaitAsync().ConfigureAwait(false);
try
{
if (!Directory.Exists(trackerFolderPath))
{
throw new DirectoryNotFoundException($"No Blockchain found at {trackerFolderPath}");
}
var tspb = Path.Combine(trackerFolderPath, TrackedScriptPubKeysFileName);
if (File.Exists(tspb) && new FileInfo(tspb).Length != 0)
{
foreach (var line in File.ReadAllLines(tspb))
{
TrackedScriptPubKeys.Add(new Script(line));
}
}
var tt = Path.Combine(trackerFolderPath, TrackedTransactionsFileName);
if (File.Exists(tt) && new FileInfo(tt).Length != 0)
{
foreach (var line in File.ReadAllLines(tt))
{
var pieces = line.Split(':');
//ProcessTransaction(new SmartTransaction(new Transaction(pieces[0]), new Height(pieces[1])));
}
}
var pbc = Path.Combine(trackerFolderPath, MerkleChainFileName);
if (File.Exists(pbc) && new FileInfo(pbc).Length != 0)
{
foreach (var block in Util.Separate(File.ReadAllBytes(pbc), blockSep))
{
try
{
SmartMerkleBlock smartMerkleBlock = SmartMerkleBlock.FromBytes(block);
MerkleChain.Add(smartMerkleBlock);
}
catch (EndOfStreamException)
{
// Some corruption is fine, the software will self correct and save the right data
}
}
if (MerkleChain.Count != 0)
{
BestHeight = MerkleChain.Max().Height;
}
}
}
finally
{
Saving.Release();
}
}
public async Task SaveAsync(string trackerFolderPath)
{
using (await AsyncLockSaving.LockAsync())
{
if (TrackedScriptPubKeys.Count > 0 || TrackedTransactions.Count > 0 || MerkleChain.Count > 0)
{
Directory.CreateDirectory(trackerFolderPath);
}
if (TrackedScriptPubKeys.Count > 0)
{
await File.WriteAllLinesAsync(
Path.Combine(trackerFolderPath, TrackedScriptPubKeysFileName),
TrackedScriptPubKeys.Select(x => x.ToString()));
}
if (TrackedTransactions.Count > 0)
{
await File.WriteAllLinesAsync(
Path.Combine(trackerFolderPath, TrackedTransactionsFileName),
TrackedTransactions
.Select(x => $"{x.Transaction.ToHex()}:{x.Height}"));
}
if (MerkleChain.Count > 0)
{
var path = Path.Combine(trackerFolderPath, MerkleChainFileName);
// remove legacy backup file
if (File.Exists(path + "_backup"))
{
File.Delete(path + "_backup");
}
using (FileStream stream = File.Open(path, FileMode.Create, FileAccess.Write))
{
var toFile = MerkleChain.First().ToBytes();
await stream.WriteAsync(toFile, 0, toFile.Length);
foreach (var block in MerkleChain.Skip(1))
{
await stream.WriteAsync(BlockSep, 0, BlockSep.Length);
var blockBytes = block.ToBytes();
await stream.WriteAsync(blockBytes, 0, blockBytes.Length);
}
}
}
}
}
public async Task LoadAsync(string partialChainFolderPath)
{
await Saving.WaitAsync().ConfigureAwait(false);
try
{
if (!Directory.Exists(partialChainFolderPath))
{
throw new DirectoryNotFoundException($"No Blockchain found at {partialChainFolderPath}");
}
var tspb = Path.Combine(partialChainFolderPath, FilesNames.TrackedScriptPubKeys.ToString());
if (File.Exists(tspb) && new FileInfo(tspb).Length != 0)
{
foreach (var line in File.ReadAllLines(tspb))
{
TrackedScriptPubKeys.Add(new Script(line));
}
}
var tt = Path.Combine(partialChainFolderPath, FilesNames.TrackedTransactions.ToString());
if (File.Exists(tt) && new FileInfo(tt).Length != 0)
{
foreach (var line in File.ReadAllLines(tt))
{
var pieces = line.Split(':');
TrackedTransactions.TryAdd(new uint256(pieces[0]), int.Parse(pieces[1]));
}
}
var pbc = Path.Combine(partialChainFolderPath, FilesNames.PartialBlockChain.ToString());
if (File.Exists(pbc) && new FileInfo(pbc).Length != 0)
{
foreach (var block in Help.Separate(File.ReadAllBytes(pbc), blockSep))
{
PartialBlock pb = new PartialBlock().FromBytes(block);
Chain.TryAdd(pb.Height, pb);
}
}
}
finally
{
Saving.Release();
}
}
public async Task SaveAsync(string partialChainFolderPath)
{
await Saving.WaitAsync().ConfigureAwait(false);
try
{
if (TrackedScriptPubKeys.Count > 0 || TrackedTransactions.Count > 0 || Chain.Count > 0)
{
Directory.CreateDirectory(partialChainFolderPath);
}
if (TrackedScriptPubKeys.Count > 0)
{
File.WriteAllLines(
Path.Combine(partialChainFolderPath, FilesNames.TrackedScriptPubKeys.ToString()),
TrackedScriptPubKeys.Select(x => x.ToString()));
}
if (TrackedTransactions.Count > 0)
{
File.WriteAllLines(
Path.Combine(partialChainFolderPath, FilesNames.TrackedTransactions.ToString()),
TrackedTransactions.Select(x => $"{x.Key}:{x.Value}"));
}
if (Chain.Count > 0)
{
byte[] toFile = Chain.Values.First().ToBytes();
foreach (var block in Chain.Values.Skip(1))
{
toFile = toFile.Concat(blockSep).Concat(block.ToBytes()).ToArray();
}
File.WriteAllBytes(Path.Combine(partialChainFolderPath, FilesNames.PartialBlockChain.ToString()),
toFile);
}
}
finally
{
Saving.Release();
}
}
/// <returns>if processed it transaction</returns>
public bool ProcessTransaction(SmartTransaction transaction)
{
// 1. If already tracking can we update it?
var found = TrackedTransactions.FirstOrDefault(x => x == transaction);
if (found != default(SmartTransaction))
{
// if in a lower level don't track
if (found.Height.Type <= transaction.Height.Type)
{
return(false);
}
else
{
// else update
TrackedTransactions.TryRemove(transaction);
TrackedTransactions.TryAdd(transaction);
return(true);
}
}
// 2. If this transaction arrived to any of our scriptpubkey track it!
if (transaction.Transaction.Outputs.Any(output => TrackedScriptPubKeys.Contains(output.ScriptPubKey)))
{
TrackedTransactions.TryAdd(transaction);
return(true);
}
// 3. If this transaction spends any of our scriptpubkeys track it!
if (transaction.Transaction.Inputs.Any(input => TrackedTransactions
.Where(ttx => ttx.GetHash() == input.PrevOut.Hash)
.Any(ttx => TrackedScriptPubKeys
.Contains(ttx.Transaction.Outputs[input.PrevOut.N].ScriptPubKey))))
{
TrackedTransactions.TryAdd(transaction);
return(true);
}
// if got so far we are not interested
return(false);
}
