Don't escalate confirmed previous/source for elections

nano/node/active_transactions.cpp

@@ -133,31 +133,37 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
 				if there are less than 100 active elections */
 				if (election_l->announcements % announcement_long == 1 && roots_size < 100 && !node.network_params.network.is_test_network ())
 				{
+					bool escalated (false);
 					std::shared_ptr<nano::block> previous;
 					auto previous_hash (election_l->status.winner->previous ());
 					if (!previous_hash.is_zero ())
 					{
 						previous = node.store.block_get (transaction, previous_hash);
-						if (previous != nullptr)
+						if (previous != nullptr && blocks.find (previous_hash) == blocks.end () && !node.block_confirmed_or_being_confirmed (transaction, previous_hash))
 						{
 							add (std::move (previous));
+							escalated = true;
 						}
 					}
 					/* If previous block not existing/not commited yet, block_source can cause segfault for state blocks
 					So source check can be done only if previous != nullptr or previous is 0 (open account) */
 					if (previous_hash.is_zero () || previous != nullptr)
 					{
 						auto source_hash (node.ledger.block_source (transaction, *election_l->status.winner));
-						if (!source_hash.is_zero ())
+						if (!source_hash.is_zero () && source_hash != previous_hash && blocks.find (source_hash) == blocks.end ())
 						{
 							auto source (node.store.block_get (transaction, source_hash));
-							if (source != nullptr)
+							if (source != nullptr && !node.block_confirmed_or_being_confirmed (transaction, source_hash))
 							{
 								add (std::move (source));
+								escalated = true;
 							}
 						}
 					}
-					election_l->update_dependent ();
+					if (escalated)
+					{
+						election_l->update_dependent ();
+					}
 				}
 			}
 			if (election_l->announcements < announcement_long || election_l->announcements % announcement_long == could_fit_delay)

nano/node/confirmation_height_processor.cpp

@@ -73,12 +73,6 @@ void nano::confirmation_height_processor::add (nano::block_hash const & hash_a)
 	condition.notify_one ();
 }
 
-// This only check top-level blocks having their confirmation height sets, not anything below
-bool nano::confirmation_height_processor::is_processing_block (nano::block_hash const & hash_a)
-{
-	return pending_confirmations.is_processing_block (hash_a);
-}
-
 /**
  * For all the blocks below this height which have been implicitly confirmed check if they
  * are open/receive blocks, and if so follow the source blocks and iteratively repeat to genesis.

nano/node/confirmation_height_processor.hpp

@@ -40,7 +40,6 @@ class confirmation_height_processor final
 	~confirmation_height_processor ();
 	void add (nano::block_hash const &);
 	void stop ();
-	bool is_processing_block (nano::block_hash const &);
 
 	/** The maximum amount of accounts to iterate over while writing */
 	static uint64_t constexpr batch_write_size = 2048;

nano/node/node.cpp

@@ -1412,7 +1412,7 @@ void nano::node::block_confirm (std::shared_ptr<nano::block> block_a)
 
 bool nano::node::block_confirmed_or_being_confirmed (nano::transaction const & transaction_a, nano::block_hash const & hash_a)
 {
-	return ledger.block_confirmed (transaction_a, hash_a) || confirmation_height_processor.is_processing_block (hash_a);
+	return ledger.block_confirmed (transaction_a, hash_a) || pending_confirmation_height.is_processing_block (hash_a);
 }
 
 nano::uint128_t nano::node::delta () const

nano/rpc_test/rpc.cpp

@@ -6122,7 +6122,7 @@ TEST (rpc, block_confirmed)
 	node->process_active (send);
 	node->block_processor.flush ();
 	system.deadline_set (10s);
-	while (!node->confirmation_height_processor.is_processing_block (send->hash ()))
+	while (!node->pending_confirmation_height.is_processing_block (send->hash ()))
 	{
 		ASSERT_NO_ERROR (system.poll ());
 	}
@@ -6141,7 +6141,7 @@ TEST (rpc, block_confirmed)
 	}
 
 	// Should no longer be processing the block after confirmation is set
-	ASSERT_FALSE (node->confirmation_height_processor.is_processing_block (send->hash ()));
+	ASSERT_FALSE (node->pending_confirmation_height.is_processing_block (send->hash ()));
 
 	// Requesting confirmation for this should now succeed
 	request.put ("hash", send->hash ().to_string ());