public bool Contains(uint256 hash)
{
lock (Lock)
{
return(ConfirmedStore.Contains(hash) || MempoolStore.Contains(hash));
}
}
public IEnumerable <uint256> GetTransactionHashes()
{
lock (Lock)
{
return(ConfirmedStore.GetTransactionHashes().Concat(MempoolStore.GetTransactionHashes()).ToList());
}
}
public bool IsEmpty()
{
lock (Lock)
{
return(ConfirmedStore.IsEmpty() && MempoolStore.IsEmpty());
}
}
public bool TryUpdate(SmartTransaction tx)
{
var hash = tx.GetHash();
lock (Lock)
{
// Do Contains first, because it's fast.
if (ConfirmedStore.TryUpdate(tx))
{
return(true);
}
else if (tx.Confirmed && MempoolStore.TryRemove(hash, out var originalTx))
{
originalTx.TryUpdate(tx);
ConfirmedStore.TryAddOrUpdate(originalTx);
return(true);
}
else if (MempoolStore.TryUpdate(tx))
{
return(true);
}
}
return(false);
}
public IEnumerable <SmartTransaction> GetTransactions()
{
lock (Lock)
{
return(ConfirmedStore.GetTransactions().Concat(MempoolStore.GetTransactions()).OrderByBlockchain().ToList());
}
}
public virtual bool TryGetTransaction(uint256 hash, [NotNullWhen(true)] out SmartTransaction?sameStx)
{
lock (Lock)
{
if (MempoolStore.TryGetTransaction(hash, out sameStx))
{
return(true);
}
return(ConfirmedStore.TryGetTransaction(hash, out sameStx));
}
}
public bool TryGetTransaction(uint256 hash, out SmartTransaction sameStx)
{
lock (Lock)
{
if (MempoolStore.TryGetTransaction(hash, out sameStx))
{
return(true);
}
return(ConfirmedStore.TryGetTransaction(hash, out sameStx));
}
}
private void EnsureConsistency()
{
lock (Lock)
{
var mempoolTransactions = MempoolStore.GetTransactionHashes();
foreach (var hash in mempoolTransactions)
{
// Contains is fast, so do this first.
if (ConfirmedStore.Contains(hash) &&
MempoolStore.TryRemove(hash, out var uTx))
{
ConfirmedStore.TryAddOrUpdate(uTx);
}
}
}
}
public IEnumerable <SmartTransaction> ReleaseToMempoolFromBlock(uint256 blockHash)
{
lock (Lock)
{
List <SmartTransaction> reorgedTxs = new();
foreach (var txHash in ConfirmedStore
.GetTransactions()
.Where(tx => tx.BlockHash == blockHash)
.Select(tx => tx.GetHash()))
{
if (ConfirmedStore.TryRemove(txHash, out var removedTx))
{
removedTx.SetUnconfirmed();
if (MempoolStore.TryAddOrUpdate(removedTx).isAdded)
{
reorgedTxs.Add(removedTx);
}
}
}
return(reorgedTxs);
}
}
public async Task InitializeAsync(bool ensureBackwardsCompatibility = true, CancellationToken cancel = default)
{
using (BenchmarkLogger.Measure())
{
var mempoolWorkFolder = Path.Combine(WorkFolderPath, "Mempool");
var confirmedWorkFolder = Path.Combine(WorkFolderPath, "ConfirmedTransactions", Constants.ConfirmedTransactionsVersion);
var initTasks = new[]
{
MempoolStore.InitializeAsync(mempoolWorkFolder, Network, $"{nameof(MempoolStore)}.{nameof(MempoolStore.InitializeAsync)}", cancel),
ConfirmedStore.InitializeAsync(confirmedWorkFolder, Network, $"{nameof(ConfirmedStore)}.{nameof(ConfirmedStore.InitializeAsync)}", cancel)
};
await Task.WhenAll(initTasks).ConfigureAwait(false);
EnsureConsistency();
if (ensureBackwardsCompatibility)
{
cancel.ThrowIfCancellationRequested();
EnsureBackwardsCompatibility();
}
}
}
private void AddOrUpdateNoLock(SmartTransaction tx)
{
var hash = tx.GetHash();
if (tx.Confirmed)
{
if (MempoolStore.TryRemove(hash, out var found))
{
found.TryUpdate(tx);
ConfirmedStore.TryAddOrUpdate(found);
}
else
{
ConfirmedStore.TryAddOrUpdate(tx);
}
}
else
{
if (!ConfirmedStore.TryUpdate(tx))
{
MempoolStore.TryAddOrUpdate(tx);
}
}
}
public async ValueTask DisposeAsync()
{
await MempoolStore.DisposeAsync().ConfigureAwait(false);
await ConfirmedStore.DisposeAsync().ConfigureAwait(false);
}
public async ValueTask DisposeAsync()
{
await MempoolStore.DisposeAsync();
await ConfirmedStore.DisposeAsync();
}
