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(); }