diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp
index 9de8ece9..daf69083 100644
--- a/nano/node/blockprocessor.cpp
+++ b/nano/node/blockprocessor.cpp
@@ -31,7 +31,7 @@ nano::block_processor::block_processor (nano::node & node_a, nano::write_databas
 	write_database_queue (write_database_queue_a),
 	state_block_signature_verification (node.checker, node.ledger.constants.epochs, node.config, node.logger, node.flags.block_processor_verification_size)
 {
-	state_block_signature_verification.blocks_verified_callback = [this] (std::deque<nano::unchecked_info> & items, std::vector<int> const & verifications, std::vector<nano::block_hash> const & hashes, std::vector<nano::signature> const & blocks_signatures) {
+	state_block_signature_verification.blocks_verified_callback = [this] (std::deque<nano::state_block_signature_verification::value_type> & items, std::vector<int> const & verifications, std::vector<nano::block_hash> const & hashes, std::vector<nano::signature> const & blocks_signatures) {
 		this->process_verified_state_blocks (items, verifications, hashes, blocks_signatures);
 	};
 	state_block_signature_verification.transition_inactive_callback = [this] () {
@@ -105,10 +105,13 @@ void nano::block_processor::add (std::shared_ptr<nano::block> const & block_a)
 
 void nano::block_processor::add (nano::unchecked_info const & info_a)
 {
-	debug_assert (!node.network_params.work.validate_entry (*info_a.block));
-	if (info_a.verified == nano::signature_verification::unknown && (info_a.block->type () == nano::block_type::state || info_a.block->type () == nano::block_type::open || !info_a.account.is_zero ()))
+	auto const & block = info_a.block;
+	auto const & account = info_a.account;
+	auto const & verified = info_a.verified;
+	debug_assert (!node.network_params.work.validate_entry (*block));
+	if (verified == nano::signature_verification::unknown && (block->type () == nano::block_type::state || block->type () == nano::block_type::open || !account.is_zero ()))
 	{
-		state_block_signature_verification.add (info_a);
+		state_block_signature_verification.add ({ block, account, verified });
 	}
 	else
 	{
@@ -124,7 +127,7 @@ void nano::block_processor::add_local (nano::unchecked_info const & info_a)
 {
 	release_assert (info_a.verified == nano::signature_verification::unknown && (info_a.block->type () == nano::block_type::state || !info_a.account.is_zero ()));
 	debug_assert (!node.network_params.work.validate_entry (*info_a.block));
-	state_block_signature_verification.add (info_a);
+	state_block_signature_verification.add ({ info_a.block, info_a.account, info_a.verified });
 }
 
 void nano::block_processor::force (std::shared_ptr<nano::block> const & block_a)
@@ -187,7 +190,7 @@ bool nano::block_processor::have_blocks ()
 	return have_blocks_ready () || state_block_signature_verification.size () != 0;
 }
 
-void nano::block_processor::process_verified_state_blocks (std::deque<nano::unchecked_info> & items, std::vector<int> const & verifications, std::vector<nano::block_hash> const & hashes, std::vector<nano::signature> const & blocks_signatures)
+void nano::block_processor::process_verified_state_blocks (std::deque<nano::state_block_signature_verification::value_type> & items, std::vector<int> const & verifications, std::vector<nano::block_hash> const & hashes, std::vector<nano::signature> const & blocks_signatures)
 {
 	{
 		nano::unique_lock<nano::mutex> lk (mutex);
@@ -195,30 +198,31 @@ void nano::block_processor::process_verified_state_blocks (std::deque<nano::unch
 		{
 			debug_assert (verifications[i] == 1 || verifications[i] == 0);
 			auto & item = items.front ();
-			if (!item.block->link ().is_zero () && node.ledger.is_epoch_link (item.block->link ()))
+			auto & [block, account, verified] = item;
+			if (!block->link ().is_zero () && node.ledger.is_epoch_link (block->link ()))
 			{
 				// Epoch blocks
 				if (verifications[i] == 1)
 				{
-					item.verified = nano::signature_verification::valid_epoch;
-					blocks.emplace_back (std::move (item));
+					verified = nano::signature_verification::valid_epoch;
+					blocks.emplace_back (block, account, verified);
 				}
 				else
 				{
 					// Possible regular state blocks with epoch link (send subtype)
-					item.verified = nano::signature_verification::unknown;
-					blocks.emplace_back (std::move (item));
+					verified = nano::signature_verification::unknown;
+					blocks.emplace_back (block, account, verified);
 				}
 			}
 			else if (verifications[i] == 1)
 			{
 				// Non epoch blocks
-				item.verified = nano::signature_verification::valid;
-				blocks.emplace_back (std::move (item));
+				verified = nano::signature_verification::valid;
+				blocks.emplace_back (block, account, verified);
 			}
 			else
 			{
-				requeue_invalid (hashes[i], item);
+				requeue_invalid (hashes[i], { block, account, verified });
 			}
 			items.pop_front ();
 		}
diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp
index 27043dfb..2b5ce082 100644
--- a/nano/node/blockprocessor.hpp
+++ b/nano/node/blockprocessor.hpp
@@ -74,7 +74,7 @@ private:
 	void process_batch (nano::unique_lock<nano::mutex> &);
 	void process_live (nano::transaction const &, nano::block_hash const &, std::shared_ptr<nano::block> const &, nano::process_return const &, nano::block_origin const = nano::block_origin::remote);
 	void requeue_invalid (nano::block_hash const &, nano::unchecked_info const &);
-	void process_verified_state_blocks (std::deque<nano::unchecked_info> &, std::vector<int> const &, std::vector<nano::block_hash> const &, std::vector<nano::signature> const &);
+	void process_verified_state_blocks (std::deque<nano::state_block_signature_verification::value_type> &, std::vector<int> const &, std::vector<nano::block_hash> const &, std::vector<nano::signature> const &);
 	bool stopped{ false };
 	bool active{ false };
 	bool awaiting_write{ false };
diff --git a/nano/node/state_block_signature_verification.cpp b/nano/node/state_block_signature_verification.cpp
index 27fb4713..553da3de 100644
--- a/nano/node/state_block_signature_verification.cpp
+++ b/nano/node/state_block_signature_verification.cpp
@@ -74,11 +74,11 @@ bool nano::state_block_signature_verification::is_active ()
 	return active;
 }
 
-void nano::state_block_signature_verification::add (nano::unchecked_info const & info_a)
+void nano::state_block_signature_verification::add (value_type const & item)
 {
 	{
 		nano::lock_guard<nano::mutex> guard (mutex);
-		state_blocks.emplace_back (info_a);
+		state_blocks.emplace_back (item);
 	}
 	condition.notify_one ();
 }
@@ -89,9 +89,9 @@ std::size_t nano::state_block_signature_verification::size ()
 	return state_blocks.size ();
 }
 
-std::deque<nano::unchecked_info> nano::state_block_signature_verification::setup_items (std::size_t max_count)
+auto nano::state_block_signature_verification::setup_items (std::size_t max_count) -> std::deque<value_type>
 {
-	std::deque<nano::unchecked_info> items;
+	std::deque<value_type> items;
 	if (state_blocks.size () <= max_count)
 	{
 		items.swap (state_blocks);
@@ -108,7 +108,7 @@ std::deque<nano::unchecked_info> nano::state_block_signature_verification::setup
 	return items;
 }
 
-void nano::state_block_signature_verification::verify_state_blocks (std::deque<nano::unchecked_info> & items)
+void nano::state_block_signature_verification::verify_state_blocks (std::deque<value_type> & items)
 {
 	if (!items.empty ())
 	{
@@ -131,23 +131,23 @@ void nano::state_block_signature_verification::verify_state_blocks (std::deque<n
 		signatures.reserve (size);
 		std::vector<int> verifications;
 		verifications.resize (size, 0);
-		for (auto & item : items)
+		for (auto const & [block, account, unused] : items)
 		{
-			hashes.push_back (item.block->hash ());
+			hashes.push_back (block->hash ());
 			messages.push_back (hashes.back ().bytes.data ());
 			lengths.push_back (sizeof (decltype (hashes)::value_type));
-			nano::account account (item.block->account ());
-			if (!item.block->link ().is_zero () && epochs.is_epoch_link (item.block->link ()))
+			nano::account account_l = block->account ();
+			if (!block->link ().is_zero () && epochs.is_epoch_link (block->link ()))
 			{
-				account = epochs.signer (epochs.epoch (item.block->link ()));
+				account_l = epochs.signer (epochs.epoch (block->link ()));
 			}
-			else if (!item.account.is_zero ())
+			else if (!account.is_zero ())
 			{
-				account = item.account;
+				account_l = account;
 			}
-			accounts.push_back (account);
+			accounts.push_back (account_l);
 			pub_keys.push_back (accounts.back ().bytes.data ());
-			blocks_signatures.push_back (item.block->block_signature ());
+			blocks_signatures.push_back (block->block_signature ());
 			signatures.push_back (blocks_signatures.back ().bytes.data ());
 		}
 		nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () };
@@ -163,6 +163,6 @@ void nano::state_block_signature_verification::verify_state_blocks (std::deque<n
 std::unique_ptr<nano::container_info_component> nano::collect_container_info (state_block_signature_verification & state_block_signature_verification, std::string const & name)
 {
 	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "state_blocks", state_block_signature_verification.size (), sizeof (nano::unchecked_info) }));
+	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "state_blocks", state_block_signature_verification.size (), sizeof (state_block_signature_verification::value_type) }));
 	return composite;
 }
diff --git a/nano/node/state_block_signature_verification.hpp b/nano/node/state_block_signature_verification.hpp
index 30a0d1e0..41fd63aa 100644
--- a/nano/node/state_block_signature_verification.hpp
+++ b/nano/node/state_block_signature_verification.hpp
@@ -17,14 +17,16 @@ class signature_checker;
 class state_block_signature_verification
 {
 public:
+	using value_type = std::tuple<std::shared_ptr<nano::block>, nano::account, nano::signature_verification>;
+
 	state_block_signature_verification (nano::signature_checker &, nano::epochs &, nano::node_config &, nano::logger_mt &, uint64_t);
 	~state_block_signature_verification ();
-	void add (nano::unchecked_info const & info_a);
+	void add (value_type const & item);
 	std::size_t size ();
 	void stop ();
 	bool is_active ();
 
-	std::function<void (std::deque<nano::unchecked_info> &, std::vector<int> const &, std::vector<nano::block_hash> const &, std::vector<nano::signature> const &)> blocks_verified_callback;
+	std::function<void (std::deque<value_type> &, std::vector<int> const &, std::vector<nano::block_hash> const &, std::vector<nano::signature> const &)> blocks_verified_callback;
 	std::function<void ()> transition_inactive_callback;
 
 private:
@@ -36,13 +38,13 @@ private:
 	nano::mutex mutex{ mutex_identifier (mutexes::state_block_signature_verification) };
 	bool stopped{ false };
 	bool active{ false };
-	std::deque<nano::unchecked_info> state_blocks;
+	std::deque<value_type> state_blocks;
 	nano::condition_variable condition;
 	std::thread thread;
 
 	void run (uint64_t block_processor_verification_size);
-	std::deque<nano::unchecked_info> setup_items (std::size_t);
-	void verify_state_blocks (std::deque<nano::unchecked_info> &);
+	std::deque<value_type> setup_items (std::size_t);
+	void verify_state_blocks (std::deque<value_type> &);
 };
 
 std::unique_ptr<nano::container_info_component> collect_container_info (state_block_signature_verification & state_block_signature_verification, std::string const & name);