From 6a65bd88e3b8aec6ad51327c36b6e1eb4ac39071 Mon Sep 17 00:00:00 2001
From: Fernando Diaz Toledano <shargon@gmail.com>
Date: Fri, 28 Jun 2024 10:14:05 +0200
Subject: [PATCH] null checks

---
 src/Neo/Ledger/MemoryPool.cs | 38 ++++++++++++++++++++----------------
 1 file changed, 21 insertions(+), 17 deletions(-)

diff --git a/src/Neo/Ledger/MemoryPool.cs b/src/Neo/Ledger/MemoryPool.cs
index 161b1193fb..538dbd98f1 100644
--- a/src/Neo/Ledger/MemoryPool.cs
+++ b/src/Neo/Ledger/MemoryPool.cs
@@ -28,8 +28,8 @@ namespace Neo.Ledger
     /// </summary>
     public class MemoryPool : IReadOnlyCollection<Transaction>
     {
-        public event EventHandler<Transaction> TransactionAdded;
-        public event EventHandler<TransactionRemovedEventArgs> TransactionRemoved;
+        public event EventHandler<Transaction>? TransactionAdded;
+        public event EventHandler<TransactionRemovedEventArgs>? TransactionRemoved;
 
         // Allow a reverified transaction to be rebroadcast if it has been this many block times since last broadcast.
         private const int BlocksTillRebroadcast = 10;
@@ -162,14 +162,14 @@ public bool ContainsKey(UInt256 hash)
         /// <param name="hash">The hash of the <see cref="Transaction"/> to get.</param>
         /// <param name="tx">When this method returns, contains the <see cref="Transaction"/> associated with the specified hash, if the hash is found; otherwise, <see langword="null"/>.</param>
         /// <returns><see langword="true"/> if the <see cref="MemoryPool"/> contains a <see cref="Transaction"/> with the specified hash; otherwise, <see langword="false"/>.</returns>
-        public bool TryGetValue(UInt256 hash, out Transaction tx)
+        public bool TryGetValue(UInt256 hash, out Transaction? tx)
         {
             _txRwLock.EnterReadLock();
             try
             {
-                bool ret = _unsortedTransactions.TryGetValue(hash, out PoolItem item)
+                var ret = _unsortedTransactions.TryGetValue(hash, out var item)
                            || _unverifiedTransactions.TryGetValue(hash, out item);
-                tx = ret ? item.Tx : null;
+                tx = ret ? item!.Tx : null;
                 return ret;
             }
             finally
@@ -252,13 +252,13 @@ public IEnumerable<Transaction> GetSortedVerifiedTransactions()
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static PoolItem GetLowestFeeTransaction(SortedSet<PoolItem> verifiedTxSorted,
-            SortedSet<PoolItem> unverifiedTxSorted, out SortedSet<PoolItem> sortedPool)
+        private static PoolItem? GetLowestFeeTransaction(SortedSet<PoolItem> verifiedTxSorted,
+            SortedSet<PoolItem> unverifiedTxSorted, out SortedSet<PoolItem>? sortedPool)
         {
-            PoolItem minItem = unverifiedTxSorted.Min;
+            var minItem = unverifiedTxSorted.Min;
             sortedPool = minItem != null ? unverifiedTxSorted : null;
 
-            PoolItem verifiedMin = verifiedTxSorted.Min;
+            var verifiedMin = verifiedTxSorted.Min;
             if (verifiedMin == null) return minItem;
 
             if (minItem != null && verifiedMin.CompareTo(minItem) >= 0)
@@ -270,7 +270,7 @@ private static PoolItem GetLowestFeeTransaction(SortedSet<PoolItem> verifiedTxSo
             return minItem;
         }
 
-        private PoolItem GetLowestFeeTransaction(out Dictionary<UInt256, PoolItem> unsortedTxPool, out SortedSet<PoolItem> sortedPool)
+        private PoolItem? GetLowestFeeTransaction(out Dictionary<UInt256, PoolItem> unsortedTxPool, out SortedSet<PoolItem>? sortedPool)
         {
             sortedPool = null;
 
@@ -291,7 +291,10 @@ internal bool CanTransactionFitInPool(Transaction tx)
         {
             if (Count < Capacity) return true;
 
-            return GetLowestFeeTransaction(out _, out _).CompareTo(tx) <= 0;
+            var item = GetLowestFeeTransaction(out _, out _);
+            if (item == null) return false;
+
+            return item.CompareTo(tx) <= 0;
         }
 
         internal VerifyResult TryAdd(Transaction tx, DataCache snapshot)
@@ -305,7 +308,7 @@ internal VerifyResult TryAdd(Transaction tx, DataCache snapshot)
 
             if (_unsortedTransactions.ContainsKey(tx.Hash)) return VerifyResult.AlreadyInPool;
 
-            List<Transaction> removedTransactions = null;
+            List<Transaction>? removedTransactions = null;
             _txRwLock.EnterWriteLock();
             try
             {
@@ -378,7 +381,7 @@ private bool CheckConflicts(Transaction tx, out List<PoolItem> conflictsList)
             // Step 2: check if unsorted transactions were in `tx`'s Conflicts attributes.
             foreach (var hash in tx.GetAttributes<Conflicts>().Select(p => p.Hash))
             {
-                if (_unsortedTransactions.TryGetValue(hash, out PoolItem unsortedTx))
+                if (_unsortedTransactions.TryGetValue(hash, out var unsortedTx))
                 {
                     if (!tx.Signers.Select(p => p.Account).Intersect(unsortedTx.Tx.Signers.Select(p => p.Account)).Any()) return false;
                     conflictsFeeSum += unsortedTx.Tx.NetworkFee;
@@ -400,7 +403,8 @@ private List<Transaction> RemoveOverCapacity()
             List<Transaction> removedTransactions = new();
             do
             {
-                PoolItem minItem = GetLowestFeeTransaction(out var unsortedPool, out var sortedPool);
+                var minItem = GetLowestFeeTransaction(out var unsortedPool, out var sortedPool);
+                if (minItem == null || sortedPool == null) break;
 
                 unsortedPool.Remove(minItem.Tx.Hash);
                 sortedPool.Remove(minItem);
@@ -417,7 +421,7 @@ private List<Transaction> RemoveOverCapacity()
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private bool TryRemoveVerified(UInt256 hash, out PoolItem item)
+        private bool TryRemoveVerified(UInt256 hash, out PoolItem? item)
         {
             if (!_unsortedTransactions.TryGetValue(hash, out item))
                 return false;
@@ -435,7 +439,7 @@ private void RemoveConflictsOfVerified(PoolItem item)
         {
             foreach (var h in item.Tx.GetAttributes<Conflicts>().Select(attr => attr.Hash))
             {
-                if (_conflicts.TryGetValue(h, out HashSet<UInt256> conflicts))
+                if (_conflicts.TryGetValue(h, out var conflicts))
                 {
                     conflicts.Remove(item.Tx.Hash);
                     if (conflicts.Count() == 0)
@@ -447,7 +451,7 @@ private void RemoveConflictsOfVerified(PoolItem item)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal bool TryRemoveUnVerified(UInt256 hash, out PoolItem item)
+        internal bool TryRemoveUnVerified(UInt256 hash, out PoolItem? item)
         {
             if (!_unverifiedTransactions.TryGetValue(hash, out item))
                 return false;