diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp
index ae49f157..66b9a86f 100644
--- a/nano/nano_node/entry.cpp
+++ b/nano/nano_node/entry.cpp
@@ -1942,7 +1942,7 @@ int main (int argc, char * const * argv)
 			nano::locked<std::vector<boost::unordered_set<nano::account>>> opened_account_versions_shared (epoch_count);
 			using opened_account_versions_t = decltype (opened_account_versions_shared)::value_type;
 			node->store.account.for_each_par (
-			[&opened_account_versions_shared, epoch_count] (nano::store::read_transaction const & /*unused*/, nano::store::iterator<nano::account, nano::account_info> i, nano::store::iterator<nano::account, nano::account_info> n) {
+			[&opened_account_versions_shared, epoch_count] (nano::store::read_transaction const & /*unused*/, auto i, auto n) {
 				// First cache locally
 				opened_account_versions_t opened_account_versions_l (epoch_count);
 				for (; i != n; ++i)
@@ -1979,7 +1979,7 @@ int main (int argc, char * const * argv)
 			nano::locked<boost::unordered_map<nano::account, std::underlying_type_t<nano::epoch>>> unopened_highest_pending_shared;
 			using unopened_highest_pending_t = decltype (unopened_highest_pending_shared)::value_type;
 			node->store.pending.for_each_par (
-			[&unopened_highest_pending_shared, &opened_accounts] (nano::store::read_transaction const & /*unused*/, nano::store::iterator<nano::pending_key, nano::pending_info> i, nano::store::iterator<nano::pending_key, nano::pending_info> n) {
+			[&unopened_highest_pending_shared, &opened_accounts] (nano::store::read_transaction const & /*unused*/, auto i, auto n) {
 				// First cache locally
 				unopened_highest_pending_t unopened_highest_pending_l;
 				for (; i != n; ++i)
diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp
index 716f78ee..a1f46c78 100644
--- a/nano/node/wallet.cpp
+++ b/nano/node/wallet.cpp
@@ -1753,22 +1753,22 @@ std::unordered_map<nano::wallet_id, std::shared_ptr<nano::wallet>> nano::wallets
 nano::uint128_t const nano::wallets::generate_priority = std::numeric_limits<nano::uint128_t>::max ();
 nano::uint128_t const nano::wallets::high_priority = std::numeric_limits<nano::uint128_t>::max () - 1;
 
-nano::store::iterator<nano::account, nano::wallet_value> nano::wallet_store::begin (store::transaction const & transaction_a)
+auto nano::wallet_store::begin (store::transaction const & transaction_a) -> iterator
 {
-	store::iterator<nano::account, nano::wallet_value> result (std::make_unique<nano::store::lmdb::iterator<nano::account, nano::wallet_value>> (transaction_a, env, handle, nano::store::lmdb::db_val (nano::account (special_count))));
+	iterator result (std::make_unique<nano::store::lmdb::iterator<nano::account, nano::wallet_value>> (transaction_a, env, handle, nano::store::lmdb::db_val (nano::account (special_count))));
 	return result;
 }
 
-nano::store::iterator<nano::account, nano::wallet_value> nano::wallet_store::begin (store::transaction const & transaction_a, nano::account const & key)
+auto nano::wallet_store::begin (store::transaction const & transaction_a, nano::account const & key) -> iterator
 {
-	store::iterator<nano::account, nano::wallet_value> result (std::make_unique<nano::store::lmdb::iterator<nano::account, nano::wallet_value>> (transaction_a, env, handle, nano::store::lmdb::db_val (key)));
+	iterator result (std::make_unique<nano::store::lmdb::iterator<nano::account, nano::wallet_value>> (transaction_a, env, handle, nano::store::lmdb::db_val (key)));
 	return result;
 }
 
-nano::store::iterator<nano::account, nano::wallet_value> nano::wallet_store::find (store::transaction const & transaction_a, nano::account const & key)
+auto nano::wallet_store::find (store::transaction const & transaction_a, nano::account const & key) -> iterator
 {
 	auto result (begin (transaction_a, key));
-	store::iterator<nano::account, nano::wallet_value> end (nullptr);
+	iterator end{ nullptr };
 	if (result != end)
 	{
 		if (result->first == key)
@@ -1787,10 +1787,11 @@ nano::store::iterator<nano::account, nano::wallet_value> nano::wallet_store::fin
 	return result;
 }
 
-nano::store::iterator<nano::account, nano::wallet_value> nano::wallet_store::end ()
+auto nano::wallet_store::end () -> iterator
 {
-	return store::iterator<nano::account, nano::wallet_value> (nullptr);
+	return iterator{ nullptr };
 }
+
 nano::mdb_wallets_store::mdb_wallets_store (std::filesystem::path const & path_a, nano::lmdb_config const & lmdb_config_a) :
 	environment (error, path_a, nano::store::lmdb::env::options::make ().set_config (lmdb_config_a).override_config_sync (nano::lmdb_config::sync_strategy::always).override_config_map_size (1ULL * 1024 * 1024 * 1024))
 {
diff --git a/nano/node/wallet.hpp b/nano/node/wallet.hpp
index 7ef86efb..ef26f4b0 100644
--- a/nano/node/wallet.hpp
+++ b/nano/node/wallet.hpp
@@ -57,6 +57,9 @@ enum class key_type
 
 class wallet_store final
 {
+public:
+	using iterator = store::iterator<nano::account, nano::wallet_value>;
+
 public:
 	wallet_store (bool &, nano::kdf &, store::transaction &, store::lmdb::env &, nano::account, unsigned, std::string const &);
 	wallet_store (bool &, nano::kdf &, store::transaction &, store::lmdb::env &, nano::account, unsigned, std::string const &, std::string const &);
@@ -89,10 +92,10 @@ public:
 	bool fetch (store::transaction const &, nano::account const &, nano::raw_key &);
 	bool exists (store::transaction const &, nano::account const &);
 	void destroy (store::transaction const &);
-	store::iterator<nano::account, nano::wallet_value> find (store::transaction const &, nano::account const &);
-	store::iterator<nano::account, nano::wallet_value> begin (store::transaction const &, nano::account const &);
-	store::iterator<nano::account, nano::wallet_value> begin (store::transaction const &);
-	store::iterator<nano::account, nano::wallet_value> end ();
+	iterator find (store::transaction const &, nano::account const &);
+	iterator begin (store::transaction const &, nano::account const &);
+	iterator begin (store::transaction const &);
+	iterator end ();
 	void derive_key (nano::raw_key &, store::transaction const &, std::string const &);
 	void serialize_json (store::transaction const &, std::string &);
 	void write_backup (store::transaction const &, std::filesystem::path const &);
diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp
index cba173a6..93eb61ce 100644
--- a/nano/secure/ledger.cpp
+++ b/nano/secure/ledger.cpp
@@ -14,7 +14,7 @@
 #include <nano/store/block.hpp>
 #include <nano/store/component.hpp>
 #include <nano/store/confirmation_height.hpp>
-#include <nano/store/final.hpp>
+#include <nano/store/final_vote.hpp>
 #include <nano/store/online_weight.hpp>
 #include <nano/store/peer.hpp>
 #include <nano/store/pending.hpp>
@@ -749,7 +749,7 @@ void nano::ledger::initialize (nano::generate_cache_flags const & generate_cache
 	if (generate_cache_flags_a.reps || generate_cache_flags_a.account_count || generate_cache_flags_a.block_count)
 	{
 		store.account.for_each_par (
-		[this] (store::read_transaction const & /*unused*/, store::iterator<nano::account, nano::account_info> i, store::iterator<nano::account, nano::account_info> n) {
+		[this] (store::read_transaction const & /*unused*/, auto i, auto n) {
 			uint64_t block_count_l{ 0 };
 			uint64_t account_count_l{ 0 };
 			for (; i != n; ++i)
@@ -763,7 +763,7 @@ void nano::ledger::initialize (nano::generate_cache_flags const & generate_cache
 		});
 
 		store.rep_weight.for_each_par (
-		[this] (store::read_transaction const & /*unused*/, store::iterator<nano::account, nano::uint128_union> i, store::iterator<nano::account, nano::uint128_union> n) {
+		[this] (store::read_transaction const & /*unused*/, auto i, auto n) {
 			nano::rep_weights rep_weights_l{ this->store.rep_weight };
 			for (; i != n; ++i)
 			{
@@ -776,7 +776,7 @@ void nano::ledger::initialize (nano::generate_cache_flags const & generate_cache
 	if (generate_cache_flags_a.cemented_count)
 	{
 		store.confirmation_height.for_each_par (
-		[this] (store::read_transaction const & /*unused*/, store::iterator<nano::account, nano::confirmation_height_info> i, store::iterator<nano::account, nano::confirmation_height_info> n) {
+		[this] (store::read_transaction const & /*unused*/, auto i, auto n) {
 			uint64_t cemented_count_l (0);
 			for (; i != n; ++i)
 			{
@@ -1523,4 +1523,4 @@ nano::container_info nano::ledger::container_info () const
 	info.put ("bootstrap_weights", bootstrap_weights);
 	info.add ("rep_weights", cache.rep_weights.container_info ());
 	return info;
-}
\ No newline at end of file
+}
diff --git a/nano/store/CMakeLists.txt b/nano/store/CMakeLists.txt
index 19ae4cf2..e5e6a8c4 100644
--- a/nano/store/CMakeLists.txt
+++ b/nano/store/CMakeLists.txt
@@ -9,7 +9,7 @@ add_library(
   db_val_impl.hpp
   iterator.hpp
   iterator_impl.hpp
-  final.hpp
+  final_vote.hpp
   lmdb/account.hpp
   lmdb/block.hpp
   lmdb/confirmation_height.hpp
@@ -32,6 +32,7 @@ add_library(
   peer.hpp
   pending.hpp
   pruned.hpp
+  rep_weight.hpp
   rocksdb/account.hpp
   rocksdb/block.hpp
   rocksdb/confirmation_height.hpp
@@ -58,7 +59,7 @@ add_library(
   db_val.cpp
   iterator.cpp
   iterator_impl.cpp
-  final.cpp
+  final_vote.cpp
   lmdb/account.cpp
   lmdb/block.cpp
   lmdb/confirmation_height.cpp
diff --git a/nano/store/account.hpp b/nano/store/account.hpp
index 749cd9c8..ffa05de0 100644
--- a/nano/store/account.hpp
+++ b/nano/store/account.hpp
@@ -19,6 +19,9 @@ namespace nano::store
  */
 class account
 {
+public:
+	using iterator = store::iterator<nano::account, nano::account_info>;
+
 public:
 	virtual void put (store::write_transaction const &, nano::account const &, nano::account_info const &) = 0;
 	virtual bool get (store::transaction const &, nano::account const &, nano::account_info &) = 0;
@@ -26,10 +29,10 @@ public:
 	virtual void del (store::write_transaction const &, nano::account const &) = 0;
 	virtual bool exists (store::transaction const &, nano::account const &) = 0;
 	virtual size_t count (store::transaction const &) = 0;
-	virtual iterator<nano::account, nano::account_info> begin (store::transaction const &, nano::account const &) const = 0;
-	virtual iterator<nano::account, nano::account_info> begin (store::transaction const &) const = 0;
-	virtual iterator<nano::account, nano::account_info> rbegin (store::transaction const &) const = 0;
-	virtual iterator<nano::account, nano::account_info> end () const = 0;
-	virtual void for_each_par (std::function<void (store::read_transaction const &, iterator<nano::account, nano::account_info>, iterator<nano::account, nano::account_info>)> const &) const = 0;
+	virtual iterator begin (store::transaction const &, nano::account const &) const = 0;
+	virtual iterator begin (store::transaction const &) const = 0;
+	virtual iterator rbegin (store::transaction const &) const = 0;
+	virtual iterator end () const = 0;
+	virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const &) const = 0;
 };
 } // namespace nano::store
diff --git a/nano/store/block.hpp b/nano/store/block.hpp
index 17f92669..acd2ba72 100644
--- a/nano/store/block.hpp
+++ b/nano/store/block.hpp
@@ -21,6 +21,9 @@ namespace nano::store
  */
 class block
 {
+public:
+	using iterator = store::iterator<nano::block_hash, block_w_sideband>;
+
 public:
 	virtual void put (store::write_transaction const &, nano::block_hash const &, nano::block const &) = 0;
 	virtual void raw_put (store::write_transaction const &, std::vector<uint8_t> const &, nano::block_hash const &) = 0;
@@ -31,9 +34,9 @@ public:
 	virtual void del (store::write_transaction const &, nano::block_hash const &) = 0;
 	virtual bool exists (store::transaction const &, nano::block_hash const &) = 0;
 	virtual uint64_t count (store::transaction const &) = 0;
-	virtual iterator<nano::block_hash, block_w_sideband> begin (store::transaction const &, nano::block_hash const &) const = 0;
-	virtual iterator<nano::block_hash, block_w_sideband> begin (store::transaction const &) const = 0;
-	virtual iterator<nano::block_hash, block_w_sideband> end () const = 0;
-	virtual void for_each_par (std::function<void (store::read_transaction const &, iterator<nano::block_hash, block_w_sideband>, iterator<nano::block_hash, block_w_sideband>)> const & action_a) const = 0;
+	virtual iterator begin (store::transaction const &, nano::block_hash const &) const = 0;
+	virtual iterator begin (store::transaction const &) const = 0;
+	virtual iterator end () const = 0;
+	virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const = 0;
 };
 } // namespace nano::store
diff --git a/nano/store/confirmation_height.hpp b/nano/store/confirmation_height.hpp
index f0cb5ee7..5569bec7 100644
--- a/nano/store/confirmation_height.hpp
+++ b/nano/store/confirmation_height.hpp
@@ -17,6 +17,9 @@ namespace nano::store
  */
 class confirmation_height
 {
+public:
+	using iterator = store::iterator<nano::account, nano::confirmation_height_info>;
+
 public:
 	virtual void put (store::write_transaction const & transaction_a, nano::account const & account_a, nano::confirmation_height_info const & confirmation_height_info_a) = 0;
 
@@ -32,9 +35,9 @@ public:
 	virtual uint64_t count (store::transaction const & transaction_a) = 0;
 	virtual void clear (store::write_transaction const &, nano::account const &) = 0;
 	virtual void clear (store::write_transaction const &) = 0;
-	virtual iterator<nano::account, nano::confirmation_height_info> begin (store::transaction const & transaction_a, nano::account const & account_a) const = 0;
-	virtual iterator<nano::account, nano::confirmation_height_info> begin (store::transaction const & transaction_a) const = 0;
-	virtual iterator<nano::account, nano::confirmation_height_info> end () const = 0;
-	virtual void for_each_par (std::function<void (store::read_transaction const &, iterator<nano::account, nano::confirmation_height_info>, iterator<nano::account, nano::confirmation_height_info>)> const &) const = 0;
+	virtual iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const = 0;
+	virtual iterator begin (store::transaction const & transaction_a) const = 0;
+	virtual iterator end () const = 0;
+	virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const &) const = 0;
 };
 } // namespace nano::store
diff --git a/nano/store/final.cpp b/nano/store/final.cpp
deleted file mode 100644
index 69d469dc..00000000
--- a/nano/store/final.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include <nano/store/final.hpp>
diff --git a/nano/store/final_vote.cpp b/nano/store/final_vote.cpp
new file mode 100644
index 00000000..0b4565c1
--- /dev/null
+++ b/nano/store/final_vote.cpp
@@ -0,0 +1 @@
+#include <nano/store/final_vote.hpp>
diff --git a/nano/store/final.hpp b/nano/store/final_vote.hpp
similarity index 64%
rename from nano/store/final.hpp
rename to nano/store/final_vote.hpp
index 1b9f1599..677159dd 100644
--- a/nano/store/final.hpp
+++ b/nano/store/final_vote.hpp
@@ -17,6 +17,9 @@ namespace nano::store
  */
 class final_vote
 {
+public:
+	using iterator = store::iterator<nano::qualified_root, nano::block_hash>;
+
 public:
 	virtual bool put (store::write_transaction const & transaction_a, nano::qualified_root const & root_a, nano::block_hash const & hash_a) = 0;
 	virtual std::vector<nano::block_hash> get (store::transaction const & transaction_a, nano::root const & root_a) = 0;
@@ -24,9 +27,9 @@ public:
 	virtual size_t count (store::transaction const & transaction_a) const = 0;
 	virtual void clear (store::write_transaction const &, nano::root const &) = 0;
 	virtual void clear (store::write_transaction const &) = 0;
-	virtual store::iterator<nano::qualified_root, nano::block_hash> begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const = 0;
-	virtual store::iterator<nano::qualified_root, nano::block_hash> begin (store::transaction const & transaction_a) const = 0;
-	virtual store::iterator<nano::qualified_root, nano::block_hash> end () const = 0;
-	virtual void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::qualified_root, nano::block_hash>, store::iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const = 0;
+	virtual iterator begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const = 0;
+	virtual iterator begin (store::transaction const & transaction_a) const = 0;
+	virtual iterator end () const = 0;
+	virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const = 0;
 };
 } // namespace nano::store
diff --git a/nano/store/iterator_impl.hpp b/nano/store/iterator_impl.hpp
index 48130d14..8daf89ea 100644
--- a/nano/store/iterator_impl.hpp
+++ b/nano/store/iterator_impl.hpp
@@ -11,14 +11,14 @@ template <typename T, typename U>
 class iterator_impl
 {
 public:
-	explicit iterator_impl (nano::store::transaction const & transaction_a) :
-		transaction{ transaction_a },
+	explicit iterator_impl (transaction const & transaction_a) :
+		txn{ transaction_a },
 		transaction_epoch{ transaction_a.epoch () }
 	{
 	}
 	virtual ~iterator_impl ()
 	{
-		debug_assert (transaction_epoch == transaction.epoch (), "invalid iterator-transaction lifetime detected");
+		debug_assert (transaction_epoch == txn.epoch (), "invalid iterator-transaction lifetime detected");
 	}
 
 	virtual iterator_impl<T, U> & operator++ () = 0;
@@ -37,7 +37,7 @@ public:
 	}
 
 protected:
-	nano::store::transaction const & transaction;
-	nano::store::transaction::epoch_t const transaction_epoch;
+	transaction const & txn;
+	transaction::epoch_t const transaction_epoch;
 };
 }
diff --git a/nano/store/lmdb/account.cpp b/nano/store/lmdb/account.cpp
index 19a35c8e..e01ce623 100644
--- a/nano/store/lmdb/account.cpp
+++ b/nano/store/lmdb/account.cpp
@@ -43,27 +43,27 @@ size_t nano::store::lmdb::account::count (store::transaction const & transaction
 	return store.count (transaction_a, tables::accounts);
 }
 
-nano::store::iterator<nano::account, nano::account_info> nano::store::lmdb::account::begin (store::transaction const & transaction, nano::account const & account) const
+auto nano::store::lmdb::account::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
 {
 	return store.make_iterator<nano::account, nano::account_info> (transaction, tables::accounts, account);
 }
 
-nano::store::iterator<nano::account, nano::account_info> nano::store::lmdb::account::begin (store::transaction const & transaction) const
+auto nano::store::lmdb::account::begin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<nano::account, nano::account_info> (transaction, tables::accounts);
 }
 
-nano::store::iterator<nano::account, nano::account_info> nano::store::lmdb::account::rbegin (store::transaction const & transaction_a) const
+auto nano::store::lmdb::account::rbegin (store::transaction const & transaction_a) const -> iterator
 {
 	return store.make_iterator<nano::account, nano::account_info> (transaction_a, tables::accounts, false);
 }
 
-nano::store::iterator<nano::account, nano::account_info> nano::store::lmdb::account::end () const
+auto nano::store::lmdb::account::end () const -> iterator
 {
-	return store::iterator<nano::account, nano::account_info> (nullptr);
+	return iterator{ nullptr };
 }
 
-void nano::store::lmdb::account::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::account_info>, store::iterator<nano::account, nano::account_info>)> const & action_a) const
+void nano::store::lmdb::account::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
 {
 	parallel_traversal<nano::uint256_t> (
 	[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
diff --git a/nano/store/lmdb/account.hpp b/nano/store/lmdb/account.hpp
index 6faaf3cf..6650f19f 100644
--- a/nano/store/lmdb/account.hpp
+++ b/nano/store/lmdb/account.hpp
@@ -22,11 +22,11 @@ public:
 	void del (store::write_transaction const & transaction_a, nano::account const & account_a) override;
 	bool exists (store::transaction const & transaction_a, nano::account const & account_a) override;
 	size_t count (store::transaction const & transaction_a) override;
-	store::iterator<nano::account, nano::account_info> begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
-	store::iterator<nano::account, nano::account_info> begin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::account, nano::account_info> rbegin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::account, nano::account_info> end () const override;
-	void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::account_info>, store::iterator<nano::account, nano::account_info>)> const & action_a) const override;
+	iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator rbegin (store::transaction const & transaction_a) const override;
+	iterator end () const override;
+	void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
 
 	/**
 	 * Maps account v1 to account information, head, rep, open, balance, timestamp and block count. (Removed)
diff --git a/nano/store/lmdb/block.cpp b/nano/store/lmdb/block.cpp
index 9d3e308a..461e0b99 100644
--- a/nano/store/lmdb/block.cpp
+++ b/nano/store/lmdb/block.cpp
@@ -134,22 +134,23 @@ uint64_t nano::store::lmdb::block::count (store::transaction const & transaction
 {
 	return store.count (transaction_a, tables::blocks);
 }
-nano::store::iterator<nano::block_hash, nano::store::block_w_sideband> nano::store::lmdb::block::begin (store::transaction const & transaction) const
+
+auto nano::store::lmdb::block::begin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<nano::block_hash, nano::store::block_w_sideband> (transaction, tables::blocks);
 }
 
-nano::store::iterator<nano::block_hash, nano::store::block_w_sideband> nano::store::lmdb::block::begin (store::transaction const & transaction, nano::block_hash const & hash) const
+auto nano::store::lmdb::block::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
 {
 	return store.make_iterator<nano::block_hash, nano::store::block_w_sideband> (transaction, tables::blocks, hash);
 }
 
-nano::store::iterator<nano::block_hash, nano::store::block_w_sideband> nano::store::lmdb::block::end () const
+auto nano::store::lmdb::block::end () const -> iterator
 {
-	return store::iterator<nano::block_hash, nano::store::block_w_sideband> (nullptr);
+	return iterator{ nullptr };
 }
 
-void nano::store::lmdb::block::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, block_w_sideband>, store::iterator<nano::block_hash, block_w_sideband>)> const & action_a) const
+void nano::store::lmdb::block::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
 {
 	parallel_traversal<nano::uint256_t> (
 	[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
diff --git a/nano/store/lmdb/block.hpp b/nano/store/lmdb/block.hpp
index 575803d8..25949451 100644
--- a/nano/store/lmdb/block.hpp
+++ b/nano/store/lmdb/block.hpp
@@ -31,10 +31,10 @@ public:
 	void del (store::write_transaction const & transaction_a, nano::block_hash const & hash_a) override;
 	bool exists (store::transaction const & transaction_a, nano::block_hash const & hash_a) override;
 	uint64_t count (store::transaction const & transaction_a) override;
-	store::iterator<nano::block_hash, nano::store::block_w_sideband> begin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::block_hash, nano::store::block_w_sideband> begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
-	store::iterator<nano::block_hash, nano::store::block_w_sideband> end () const override;
-	void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, block_w_sideband>, store::iterator<nano::block_hash, block_w_sideband>)> const & action_a) const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
+	iterator end () const override;
+	void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
 
 	/**
 	 * Contains block_sideband and block for all block types (legacy send/change/open/receive & state blocks)
diff --git a/nano/store/lmdb/confirmation_height.cpp b/nano/store/lmdb/confirmation_height.cpp
index 1ce01eda..234c5684 100644
--- a/nano/store/lmdb/confirmation_height.cpp
+++ b/nano/store/lmdb/confirmation_height.cpp
@@ -59,22 +59,22 @@ void nano::store::lmdb::confirmation_height::clear (store::write_transaction con
 	store.drop (transaction_a, nano::tables::confirmation_height);
 }
 
-nano::store::iterator<nano::account, nano::confirmation_height_info> nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction, nano::account const & account) const
+auto nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
 {
 	return store.make_iterator<nano::account, nano::confirmation_height_info> (transaction, tables::confirmation_height, account);
 }
 
-nano::store::iterator<nano::account, nano::confirmation_height_info> nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction) const
+auto nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<nano::account, nano::confirmation_height_info> (transaction, tables::confirmation_height);
 }
 
-nano::store::iterator<nano::account, nano::confirmation_height_info> nano::store::lmdb::confirmation_height::end () const
+auto nano::store::lmdb::confirmation_height::end () const -> iterator
 {
-	return store::iterator<nano::account, nano::confirmation_height_info> (nullptr);
+	return iterator{ nullptr };
 }
 
-void nano::store::lmdb::confirmation_height::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::confirmation_height_info>, store::iterator<nano::account, nano::confirmation_height_info>)> const & action_a) const
+void nano::store::lmdb::confirmation_height::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
 {
 	parallel_traversal<nano::uint256_t> (
 	[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
diff --git a/nano/store/lmdb/confirmation_height.hpp b/nano/store/lmdb/confirmation_height.hpp
index 4674f811..de353245 100644
--- a/nano/store/lmdb/confirmation_height.hpp
+++ b/nano/store/lmdb/confirmation_height.hpp
@@ -23,10 +23,10 @@ public:
 	uint64_t count (store::transaction const & transaction_a) override;
 	void clear (store::write_transaction const & transaction_a, nano::account const & account_a) override;
 	void clear (store::write_transaction const & transaction_a) override;
-	store::iterator<nano::account, nano::confirmation_height_info> begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
-	store::iterator<nano::account, nano::confirmation_height_info> begin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::account, nano::confirmation_height_info> end () const override;
-	void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::confirmation_height_info>, store::iterator<nano::account, nano::confirmation_height_info>)> const & action_a) const override;
+	iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator end () const override;
+	void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
 
 	/*
 	 * Confirmation height of an account, and the hash for the block at that height
diff --git a/nano/store/lmdb/final_vote.cpp b/nano/store/lmdb/final_vote.cpp
index 2ae93bd5..a26153d1 100644
--- a/nano/store/lmdb/final_vote.cpp
+++ b/nano/store/lmdb/final_vote.cpp
@@ -64,22 +64,22 @@ void nano::store::lmdb::final_vote::clear (store::write_transaction const & tran
 	store.drop (transaction_a, nano::tables::final_votes);
 }
 
-nano::store::iterator<nano::qualified_root, nano::block_hash> nano::store::lmdb::final_vote::begin (store::transaction const & transaction, nano::qualified_root const & root) const
+auto nano::store::lmdb::final_vote::begin (store::transaction const & transaction, nano::qualified_root const & root) const -> iterator
 {
 	return store.make_iterator<nano::qualified_root, nano::block_hash> (transaction, tables::final_votes, root);
 }
 
-nano::store::iterator<nano::qualified_root, nano::block_hash> nano::store::lmdb::final_vote::begin (store::transaction const & transaction) const
+auto nano::store::lmdb::final_vote::begin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<nano::qualified_root, nano::block_hash> (transaction, tables::final_votes);
 }
 
-nano::store::iterator<nano::qualified_root, nano::block_hash> nano::store::lmdb::final_vote::end () const
+auto nano::store::lmdb::final_vote::end () const -> iterator
 {
-	return store::iterator<nano::qualified_root, nano::block_hash> (nullptr);
+	return iterator{ nullptr };
 }
 
-void nano::store::lmdb::final_vote::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::qualified_root, nano::block_hash>, store::iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const
+void nano::store::lmdb::final_vote::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
 {
 	parallel_traversal<nano::uint512_t> (
 	[&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) {
diff --git a/nano/store/lmdb/final_vote.hpp b/nano/store/lmdb/final_vote.hpp
index 92fc5253..9b72b085 100644
--- a/nano/store/lmdb/final_vote.hpp
+++ b/nano/store/lmdb/final_vote.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <nano/store/final.hpp>
+#include <nano/store/final_vote.hpp>
 
 #include <lmdb/libraries/liblmdb/lmdb.h>
 
@@ -23,10 +23,10 @@ public:
 	size_t count (store::transaction const & transaction_a) const override;
 	void clear (store::write_transaction const & transaction_a, nano::root const & root_a) override;
 	void clear (store::write_transaction const & transaction_a) override;
-	store::iterator<nano::qualified_root, nano::block_hash> begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const override;
-	store::iterator<nano::qualified_root, nano::block_hash> begin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::qualified_root, nano::block_hash> end () const override;
-	void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::qualified_root, nano::block_hash>, store::iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const override;
+	iterator begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator end () const override;
+	void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
 
 	/**
 	 * Maps root to block hash for generated final votes.
diff --git a/nano/store/lmdb/iterator.hpp b/nano/store/lmdb/iterator.hpp
index 3c2fe197..621d6980 100644
--- a/nano/store/lmdb/iterator.hpp
+++ b/nano/store/lmdb/iterator.hpp
@@ -14,8 +14,8 @@ template <typename T, typename U>
 class iterator : public iterator_impl<T, U>
 {
 public:
-	iterator (store::transaction const & transaction_a, env const & env_a, MDB_dbi db_a, MDB_val const & val_a = MDB_val{}, bool const direction_asc = true) :
-		nano::store::iterator_impl<T, U> (transaction_a)
+	iterator (transaction const & transaction_a, env const & env_a, MDB_dbi db_a, MDB_val const & val_a = MDB_val{}, bool const direction_asc = true) :
+		iterator_impl<T, U> (transaction_a)
 	{
 		auto status (mdb_cursor_open (env_a.tx (transaction_a), db_a, &cursor));
 		release_assert (status == 0);
@@ -47,14 +47,14 @@ public:
 
 	iterator () = default;
 
-	iterator (nano::store::lmdb::iterator<T, U> && other_a)
+	iterator (iterator<T, U> && other_a)
 	{
 		cursor = other_a.cursor;
 		other_a.cursor = nullptr;
 		current = other_a.current;
 	}
 
-	iterator (nano::store::lmdb::iterator<T, U> const &) = delete;
+	iterator (iterator<T, U> const &) = delete;
 
 	~iterator ()
 	{
@@ -64,7 +64,7 @@ public:
 		}
 	}
 
-	store::iterator_impl<T, U> & operator++ () override
+	iterator_impl<T, U> & operator++ () override
 	{
 		debug_assert (cursor != nullptr);
 		auto status (mdb_cursor_get (cursor, &current.first.value, &current.second.value, MDB_NEXT));
@@ -80,7 +80,7 @@ public:
 		return *this;
 	}
 
-	store::iterator_impl<T, U> & operator-- () override
+	iterator_impl<T, U> & operator-- () override
 	{
 		debug_assert (cursor != nullptr);
 		auto status (mdb_cursor_get (cursor, &current.first.value, &current.second.value, MDB_PREV));
@@ -101,9 +101,9 @@ public:
 		return &current;
 	}
 
-	bool operator== (nano::store::lmdb::iterator<T, U> const & base_a) const
+	bool operator== (iterator<T, U> const & base_a) const
 	{
-		auto const other_a (boost::polymorphic_downcast<nano::store::lmdb::iterator<T, U> const *> (&base_a));
+		auto const other_a (boost::polymorphic_downcast<iterator<T, U> const *> (&base_a));
 		auto result (current.first.data () == other_a->current.first.data ());
 		debug_assert (!result || (current.first.size () == other_a->current.first.size ()));
 		debug_assert (!result || (current.second.data () == other_a->current.second.data ()));
@@ -111,9 +111,9 @@ public:
 		return result;
 	}
 
-	bool operator== (store::iterator_impl<T, U> const & base_a) const override
+	bool operator== (iterator_impl<T, U> const & base_a) const override
 	{
-		auto const other_a (boost::polymorphic_downcast<nano::store::lmdb::iterator<T, U> const *> (&base_a));
+		auto const other_a (boost::polymorphic_downcast<iterator<T, U> const *> (&base_a));
 		auto result (current.first.data () == other_a->current.first.data ());
 		debug_assert (!result || (current.first.size () == other_a->current.first.size ()));
 		debug_assert (!result || (current.second.data () == other_a->current.second.data ()));
@@ -151,7 +151,7 @@ public:
 		debug_assert (is_end_sentinal ());
 	}
 
-	nano::store::lmdb::iterator<T, U> & operator= (nano::store::lmdb::iterator<T, U> && other_a)
+	iterator<T, U> & operator= (iterator<T, U> && other_a)
 	{
 		if (cursor != nullptr)
 		{
@@ -164,7 +164,7 @@ public:
 		return *this;
 	}
 
-	store::iterator_impl<T, U> & operator= (store::iterator_impl<T, U> const &) = delete;
+	iterator_impl<T, U> & operator= (iterator_impl<T, U> const &) = delete;
 	MDB_cursor * cursor{ nullptr };
 	std::pair<store::db_val<MDB_val>, store::db_val<MDB_val>> current;
 };
@@ -176,21 +176,21 @@ template <typename T, typename U>
 class merge_iterator : public iterator_impl<T, U>
 {
 public:
-	merge_iterator (store::transaction const & transaction_a, MDB_dbi db1_a, MDB_dbi db2_a) :
-		impl1 (std::make_unique<nano::store::lmdb::iterator<T, U>> (transaction_a, db1_a)),
-		impl2 (std::make_unique<nano::store::lmdb::iterator<T, U>> (transaction_a, db2_a))
+	merge_iterator (transaction const & transaction_a, MDB_dbi db1_a, MDB_dbi db2_a) :
+		impl1 (std::make_unique<iterator<T, U>> (transaction_a, db1_a)),
+		impl2 (std::make_unique<iterator<T, U>> (transaction_a, db2_a))
 	{
 	}
 
 	merge_iterator () :
-		impl1 (std::make_unique<nano::store::lmdb::iterator<T, U>> ()),
-		impl2 (std::make_unique<nano::store::lmdb::iterator<T, U>> ())
+		impl1 (std::make_unique<iterator<T, U>> ()),
+		impl2 (std::make_unique<iterator<T, U>> ())
 	{
 	}
 
-	merge_iterator (store::transaction const & transaction_a, MDB_dbi db1_a, MDB_dbi db2_a, MDB_val const & val_a) :
-		impl1 (std::make_unique<nano::store::lmdb::iterator<T, U>> (transaction_a, db1_a, val_a)),
-		impl2 (std::make_unique<nano::store::lmdb::iterator<T, U>> (transaction_a, db2_a, val_a))
+	merge_iterator (transaction const & transaction_a, MDB_dbi db1_a, MDB_dbi db2_a, MDB_val const & val_a) :
+		impl1 (std::make_unique<iterator<T, U>> (transaction_a, db1_a, val_a)),
+		impl2 (std::make_unique<iterator<T, U>> (transaction_a, db2_a, val_a))
 	{
 	}
 
@@ -202,13 +202,13 @@ public:
 
 	merge_iterator (merge_iterator<T, U> const &) = delete;
 
-	store::iterator_impl<T, U> & operator++ () override
+	iterator_impl<T, U> & operator++ () override
 	{
 		++least_iterator ();
 		return *this;
 	}
 
-	store::iterator_impl<T, U> & operator-- () override
+	iterator_impl<T, U> & operator-- () override
 	{
 		--least_iterator ();
 		return *this;
@@ -229,7 +229,7 @@ public:
 		return !(*this == base_a);
 	}
 
-	bool operator== (store::iterator_impl<T, U> const & base_a) const override
+	bool operator== (iterator_impl<T, U> const & base_a) const override
 	{
 		debug_assert ((dynamic_cast<merge_iterator<T, U> const *> (&base_a) != nullptr) && "Incompatible iterator comparison");
 		auto & other (static_cast<merge_iterator<T, U> const &> (base_a));
@@ -267,9 +267,9 @@ public:
 	mutable bool from_first_database{ false };
 
 private:
-	nano::store::lmdb::iterator<T, U> & least_iterator () const
+	iterator<T, U> & least_iterator () const
 	{
-		nano::store::lmdb::iterator<T, U> * result;
+		iterator<T, U> * result;
 		if (impl1->is_end_sentinal ())
 		{
 			result = impl2.get ();
@@ -304,7 +304,7 @@ private:
 		return *result;
 	}
 
-	std::unique_ptr<nano::store::lmdb::iterator<T, U>> impl1;
-	std::unique_ptr<nano::store::lmdb::iterator<T, U>> impl2;
+	std::unique_ptr<iterator<T, U>> impl1;
+	std::unique_ptr<iterator<T, U>> impl2;
 };
 }
diff --git a/nano/store/lmdb/online_weight.cpp b/nano/store/lmdb/online_weight.cpp
index 647aaf34..c9e553a0 100644
--- a/nano/store/lmdb/online_weight.cpp
+++ b/nano/store/lmdb/online_weight.cpp
@@ -18,19 +18,19 @@ void nano::store::lmdb::online_weight::del (store::write_transaction const & tra
 	store.release_assert_success (status);
 }
 
-nano::store::iterator<uint64_t, nano::amount> nano::store::lmdb::online_weight::begin (store::transaction const & transaction) const
+auto nano::store::lmdb::online_weight::begin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<uint64_t, nano::amount> (transaction, tables::online_weight);
 }
 
-nano::store::iterator<uint64_t, nano::amount> nano::store::lmdb::online_weight::rbegin (store::transaction const & transaction) const
+auto nano::store::lmdb::online_weight::rbegin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<uint64_t, nano::amount> (transaction, tables::online_weight, false);
 }
 
-nano::store::iterator<uint64_t, nano::amount> nano::store::lmdb::online_weight::end () const
+auto nano::store::lmdb::online_weight::end () const -> iterator
 {
-	return store::iterator<uint64_t, nano::amount> (nullptr);
+	return iterator{ nullptr };
 }
 
 size_t nano::store::lmdb::online_weight::count (store::transaction const & transaction) const
diff --git a/nano/store/lmdb/online_weight.hpp b/nano/store/lmdb/online_weight.hpp
index 0567c63d..fe281035 100644
--- a/nano/store/lmdb/online_weight.hpp
+++ b/nano/store/lmdb/online_weight.hpp
@@ -15,9 +15,9 @@ public:
 	explicit online_weight (nano::store::lmdb::component & store_a);
 	void put (store::write_transaction const & transaction_a, uint64_t time_a, nano::amount const & amount_a) override;
 	void del (store::write_transaction const & transaction_a, uint64_t time_a) override;
-	store::iterator<uint64_t, nano::amount> begin (store::transaction const & transaction_a) const override;
-	store::iterator<uint64_t, nano::amount> rbegin (store::transaction const & transaction_a) const override;
-	store::iterator<uint64_t, nano::amount> end () const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator rbegin (store::transaction const & transaction_a) const override;
+	iterator end () const override;
 	size_t count (store::transaction const & transaction_a) const override;
 	void clear (store::write_transaction const & transaction_a) override;
 
diff --git a/nano/store/lmdb/peer.cpp b/nano/store/lmdb/peer.cpp
index c43412d9..a91cd300 100644
--- a/nano/store/lmdb/peer.cpp
+++ b/nano/store/lmdb/peer.cpp
@@ -45,12 +45,12 @@ void nano::store::lmdb::peer::clear (store::write_transaction const & transactio
 	store.release_assert_success (status);
 }
 
-nano::store::iterator<nano::endpoint_key, nano::millis_t> nano::store::lmdb::peer::begin (store::transaction const & transaction) const
+auto nano::store::lmdb::peer::begin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<nano::endpoint_key, nano::millis_t> (transaction, tables::peers);
 }
 
-nano::store::iterator<nano::endpoint_key, nano::millis_t> nano::store::lmdb::peer::end () const
+auto nano::store::lmdb::peer::end () const -> iterator
 {
-	return store::iterator<nano::endpoint_key, nano::millis_t> (nullptr);
+	return iterator{ nullptr };
 }
diff --git a/nano/store/lmdb/peer.hpp b/nano/store/lmdb/peer.hpp
index 8197c00b..db39eb51 100644
--- a/nano/store/lmdb/peer.hpp
+++ b/nano/store/lmdb/peer.hpp
@@ -19,8 +19,8 @@ public:
 	bool exists (store::transaction const &, nano::endpoint_key const & endpoint) const override;
 	size_t count (store::transaction const &) const override;
 	void clear (store::write_transaction const &) override;
-	store::iterator<nano::endpoint_key, nano::millis_t> begin (store::transaction const &) const override;
-	store::iterator<nano::endpoint_key, nano::millis_t> end () const override;
+	iterator begin (store::transaction const &) const override;
+	iterator end () const override;
 
 	/*
 	 * Endpoints for peers
diff --git a/nano/store/lmdb/pending.cpp b/nano/store/lmdb/pending.cpp
index cabb7089..925203d5 100644
--- a/nano/store/lmdb/pending.cpp
+++ b/nano/store/lmdb/pending.cpp
@@ -45,22 +45,22 @@ bool nano::store::lmdb::pending::any (store::transaction const & transaction_a,
 	return iterator != end () && nano::pending_key (iterator->first).account == account_a;
 }
 
-nano::store::iterator<nano::pending_key, nano::pending_info> nano::store::lmdb::pending::begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const
+auto nano::store::lmdb::pending::begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const -> iterator
 {
 	return store.make_iterator<nano::pending_key, nano::pending_info> (transaction_a, tables::pending, key_a);
 }
 
-nano::store::iterator<nano::pending_key, nano::pending_info> nano::store::lmdb::pending::begin (store::transaction const & transaction_a) const
+auto nano::store::lmdb::pending::begin (store::transaction const & transaction_a) const -> iterator
 {
 	return store.make_iterator<nano::pending_key, nano::pending_info> (transaction_a, tables::pending);
 }
 
-nano::store::iterator<nano::pending_key, nano::pending_info> nano::store::lmdb::pending::end () const
+auto nano::store::lmdb::pending::end () const -> iterator
 {
-	return store::iterator<nano::pending_key, nano::pending_info> (nullptr);
+	return iterator{ nullptr };
 }
 
-void nano::store::lmdb::pending::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::pending_key, nano::pending_info>, store::iterator<nano::pending_key, nano::pending_info>)> const & action_a) const
+void nano::store::lmdb::pending::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
 {
 	parallel_traversal<nano::uint512_t> (
 	[&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) {
diff --git a/nano/store/lmdb/pending.hpp b/nano/store/lmdb/pending.hpp
index 13cd9172..46b5f794 100644
--- a/nano/store/lmdb/pending.hpp
+++ b/nano/store/lmdb/pending.hpp
@@ -22,10 +22,10 @@ public:
 	std::optional<nano::pending_info> get (store::transaction const & transaction_a, nano::pending_key const & key_a) override;
 	bool exists (store::transaction const & transaction_a, nano::pending_key const & key_a) override;
 	bool any (store::transaction const & transaction_a, nano::account const & account_a) override;
-	store::iterator<nano::pending_key, nano::pending_info> begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const override;
-	store::iterator<nano::pending_key, nano::pending_info> begin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::pending_key, nano::pending_info> end () const override;
-	void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::pending_key, nano::pending_info>, store::iterator<nano::pending_key, nano::pending_info>)> const & action_a) const override;
+	iterator begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator end () const override;
+	void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
 
 	/**
 	 * Maps min_version 0 (destination account, pending block) to (source account, amount). (Removed)
diff --git a/nano/store/lmdb/pruned.cpp b/nano/store/lmdb/pruned.cpp
index 2be19c24..30bf1e0b 100644
--- a/nano/store/lmdb/pruned.cpp
+++ b/nano/store/lmdb/pruned.cpp
@@ -45,22 +45,22 @@ void nano::store::lmdb::pruned::clear (store::write_transaction const & transact
 	store.release_assert_success (status);
 }
 
-nano::store::iterator<nano::block_hash, std::nullptr_t> nano::store::lmdb::pruned::begin (store::transaction const & transaction, nano::block_hash const & hash) const
+auto nano::store::lmdb::pruned::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
 {
 	return store.make_iterator<nano::block_hash, std::nullptr_t> (transaction, tables::pruned, hash);
 }
 
-nano::store::iterator<nano::block_hash, std::nullptr_t> nano::store::lmdb::pruned::begin (store::transaction const & transaction) const
+auto nano::store::lmdb::pruned::begin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<nano::block_hash, std::nullptr_t> (transaction, tables::pruned);
 }
 
-nano::store::iterator<nano::block_hash, std::nullptr_t> nano::store::lmdb::pruned::end () const
+auto nano::store::lmdb::pruned::end () const -> iterator
 {
-	return store::iterator<nano::block_hash, std::nullptr_t> (nullptr);
+	return iterator{ nullptr };
 }
 
-void nano::store::lmdb::pruned::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, std::nullptr_t>, store::iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const
+void nano::store::lmdb::pruned::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
 {
 	parallel_traversal<nano::uint256_t> (
 	[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
diff --git a/nano/store/lmdb/pruned.hpp b/nano/store/lmdb/pruned.hpp
index 0aa2d7fc..de1be14a 100644
--- a/nano/store/lmdb/pruned.hpp
+++ b/nano/store/lmdb/pruned.hpp
@@ -19,10 +19,10 @@ public:
 	nano::block_hash random (store::transaction const & transaction_a) override;
 	size_t count (store::transaction const & transaction_a) const override;
 	void clear (store::write_transaction const & transaction_a) override;
-	store::iterator<nano::block_hash, std::nullptr_t> begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
-	store::iterator<nano::block_hash, std::nullptr_t> begin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::block_hash, std::nullptr_t> end () const override;
-	void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, std::nullptr_t>, store::iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const override;
+	iterator begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator end () const override;
+	void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
 
 	/**
 	 * Pruned blocks hashes
diff --git a/nano/store/lmdb/rep_weight.cpp b/nano/store/lmdb/rep_weight.cpp
index 529efae6..d01d204d 100644
--- a/nano/store/lmdb/rep_weight.cpp
+++ b/nano/store/lmdb/rep_weight.cpp
@@ -43,22 +43,22 @@ void nano::store::lmdb::rep_weight::del (store::write_transaction const & txn_a,
 	store.release_assert_success (status);
 }
 
-nano::store::iterator<nano::account, nano::uint128_union> nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a, nano::account const & representative_a) const
+auto nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a, nano::account const & representative_a) const -> iterator
 {
 	return store.make_iterator<nano::account, nano::uint128_union> (transaction_a, tables::rep_weights, representative_a);
 }
 
-nano::store::iterator<nano::account, nano::uint128_union> nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a) const
+auto nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a) const -> iterator
 {
 	return store.make_iterator<nano::account, nano::uint128_union> (transaction_a, tables::rep_weights);
 }
 
-nano::store::iterator<nano::account, nano::uint128_union> nano::store::lmdb::rep_weight::end () const
+auto nano::store::lmdb::rep_weight::end () const -> iterator
 {
-	return nano::store::iterator<nano::account, nano::uint128_union> (nullptr);
+	return iterator{ nullptr };
 }
 
-void nano::store::lmdb::rep_weight::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::uint128_union>, store::iterator<nano::account, nano::uint128_union>)> const & action_a) const
+void nano::store::lmdb::rep_weight::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
 {
 	parallel_traversal<nano::uint256_t> (
 	[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
diff --git a/nano/store/lmdb/rep_weight.hpp b/nano/store/lmdb/rep_weight.hpp
index 2a6ef53c..809b23ae 100644
--- a/nano/store/lmdb/rep_weight.hpp
+++ b/nano/store/lmdb/rep_weight.hpp
@@ -20,10 +20,10 @@ public:
 	nano::uint128_t get (store::transaction const & txn_a, nano::account const & representative_a) override;
 	void put (store::write_transaction const & txn_a, nano::account const & representative_a, nano::uint128_t const & weight_a) override;
 	void del (store::write_transaction const &, nano::account const & representative_a) override;
-	store::iterator<nano::account, nano::uint128_union> begin (store::transaction const & transaction_a, nano::account const & representative_a) const override;
-	store::iterator<nano::account, nano::uint128_union> begin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::account, nano::uint128_union> end () const override;
-	void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::uint128_union>, store::iterator<nano::account, nano::uint128_union>)> const & action_a) const override;
+	iterator begin (store::transaction const & transaction_a, nano::account const & representative_a) const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator end () const override;
+	void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
 
 	/**
 	 * Representative weights
diff --git a/nano/store/online_weight.hpp b/nano/store/online_weight.hpp
index aa17938e..595a5151 100644
--- a/nano/store/online_weight.hpp
+++ b/nano/store/online_weight.hpp
@@ -17,12 +17,15 @@ namespace nano::store
  */
 class online_weight
 {
+public:
+	using iterator = store::iterator<uint64_t, nano::amount>;
+
 public:
 	virtual void put (store::write_transaction const &, uint64_t, nano::amount const &) = 0;
 	virtual void del (store::write_transaction const &, uint64_t) = 0;
-	virtual store::iterator<uint64_t, nano::amount> begin (store::transaction const &) const = 0;
-	virtual store::iterator<uint64_t, nano::amount> rbegin (store::transaction const &) const = 0;
-	virtual store::iterator<uint64_t, nano::amount> end () const = 0;
+	virtual iterator begin (store::transaction const &) const = 0;
+	virtual iterator rbegin (store::transaction const &) const = 0;
+	virtual iterator end () const = 0;
 	virtual size_t count (store::transaction const &) const = 0;
 	virtual void clear (store::write_transaction const &) = 0;
 };
diff --git a/nano/store/peer.hpp b/nano/store/peer.hpp
index 82f9a538..58e3c1d1 100644
--- a/nano/store/peer.hpp
+++ b/nano/store/peer.hpp
@@ -17,6 +17,9 @@ namespace nano::store
  */
 class peer
 {
+public:
+	using iterator = store::iterator<nano::endpoint_key, nano::millis_t>;
+
 public:
 	/// Returns true if the peer was inserted, false if it was already in the container
 	virtual void put (store::write_transaction const &, nano::endpoint_key const & endpoint, nano::millis_t timestamp) = 0;
@@ -25,7 +28,7 @@ public:
 	virtual bool exists (store::transaction const &, nano::endpoint_key const & endpoint) const = 0;
 	virtual size_t count (store::transaction const &) const = 0;
 	virtual void clear (store::write_transaction const &) = 0;
-	virtual store::iterator<nano::endpoint_key, nano::millis_t> begin (store::transaction const &) const = 0;
-	virtual store::iterator<nano::endpoint_key, nano::millis_t> end () const = 0;
+	virtual iterator begin (store::transaction const &) const = 0;
+	virtual iterator end () const = 0;
 };
 } // namespace nano::store
diff --git a/nano/store/pending.hpp b/nano/store/pending.hpp
index 23272cba..771bfba5 100644
--- a/nano/store/pending.hpp
+++ b/nano/store/pending.hpp
@@ -29,9 +29,9 @@ public:
 	virtual std::optional<nano::pending_info> get (store::transaction const &, nano::pending_key const &) = 0;
 	virtual bool exists (store::transaction const &, nano::pending_key const &) = 0;
 	virtual bool any (store::transaction const &, nano::account const &) = 0;
-	virtual store::iterator<nano::pending_key, nano::pending_info> begin (store::transaction const &, nano::pending_key const &) const = 0;
-	virtual store::iterator<nano::pending_key, nano::pending_info> begin (store::transaction const &) const = 0;
-	virtual store::iterator<nano::pending_key, nano::pending_info> end () const = 0;
-	virtual void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::pending_key, nano::pending_info>, store::iterator<nano::pending_key, nano::pending_info>)> const & action_a) const = 0;
+	virtual iterator begin (store::transaction const &, nano::pending_key const &) const = 0;
+	virtual iterator begin (store::transaction const &) const = 0;
+	virtual iterator end () const = 0;
+	virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const = 0;
 };
 } // namespace nano::store
diff --git a/nano/store/pruned.hpp b/nano/store/pruned.hpp
index cc40c812..5899c3d0 100644
--- a/nano/store/pruned.hpp
+++ b/nano/store/pruned.hpp
@@ -17,6 +17,9 @@ namespace nano::store
  */
 class pruned
 {
+public:
+	using iterator = store::iterator<nano::block_hash, std::nullptr_t>;
+
 public:
 	virtual void put (store::write_transaction const & transaction_a, nano::block_hash const & hash_a) = 0;
 	virtual void del (store::write_transaction const & transaction_a, nano::block_hash const & hash_a) = 0;
@@ -24,9 +27,9 @@ public:
 	virtual nano::block_hash random (store::transaction const & transaction_a) = 0;
 	virtual size_t count (store::transaction const & transaction_a) const = 0;
 	virtual void clear (store::write_transaction const &) = 0;
-	virtual store::iterator<nano::block_hash, std::nullptr_t> begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const = 0;
-	virtual store::iterator<nano::block_hash, std::nullptr_t> begin (store::transaction const & transaction_a) const = 0;
-	virtual store::iterator<nano::block_hash, std::nullptr_t> end () const = 0;
-	virtual void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, std::nullptr_t>, store::iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const = 0;
+	virtual iterator begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const = 0;
+	virtual iterator begin (store::transaction const & transaction_a) const = 0;
+	virtual iterator end () const = 0;
+	virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const = 0;
 };
 } // namespace nano::store
diff --git a/nano/store/rep_weight.hpp b/nano/store/rep_weight.hpp
index 72ac9f84..5d8fdb80 100644
--- a/nano/store/rep_weight.hpp
+++ b/nano/store/rep_weight.hpp
@@ -18,15 +18,18 @@ namespace nano::store
  */
 class rep_weight
 {
+public:
+	using iterator = store::iterator<nano::account, nano::uint128_union>;
+
 public:
 	virtual ~rep_weight (){};
 	virtual uint64_t count (store::transaction const & txn_a) = 0;
 	virtual nano::uint128_t get (store::transaction const & txn_a, nano::account const & representative_a) = 0;
 	virtual void put (store::write_transaction const & txn_a, nano::account const & representative_a, nano::uint128_t const & weight_a) = 0;
 	virtual void del (store::write_transaction const &, nano::account const & representative_a) = 0;
-	virtual store::iterator<nano::account, nano::uint128_union> begin (store::transaction const & transaction_a, nano::account const & representative_a) const = 0;
-	virtual store::iterator<nano::account, nano::uint128_union> begin (store::transaction const & transaction_a) const = 0;
-	virtual store::iterator<nano::account, nano::uint128_union> end () const = 0;
-	virtual void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::uint128_union>, store::iterator<nano::account, nano::uint128_union>)> const & action_a) const = 0;
+	virtual iterator begin (store::transaction const & transaction_a, nano::account const & representative_a) const = 0;
+	virtual iterator begin (store::transaction const & transaction_a) const = 0;
+	virtual iterator end () const = 0;
+	virtual void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const = 0;
 };
 }
diff --git a/nano/store/rocksdb/account.cpp b/nano/store/rocksdb/account.cpp
index 8ee01b98..9040f22e 100644
--- a/nano/store/rocksdb/account.cpp
+++ b/nano/store/rocksdb/account.cpp
@@ -42,27 +42,27 @@ size_t nano::store::rocksdb::account::count (store::transaction const & transact
 	return store.count (transaction_a, tables::accounts);
 }
 
-nano::store::iterator<nano::account, nano::account_info> nano::store::rocksdb::account::begin (store::transaction const & transaction, nano::account const & account) const
+auto nano::store::rocksdb::account::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
 {
 	return store.make_iterator<nano::account, nano::account_info> (transaction, tables::accounts, account);
 }
 
-nano::store::iterator<nano::account, nano::account_info> nano::store::rocksdb::account::begin (store::transaction const & transaction) const
+auto nano::store::rocksdb::account::begin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<nano::account, nano::account_info> (transaction, tables::accounts);
 }
 
-nano::store::iterator<nano::account, nano::account_info> nano::store::rocksdb::account::rbegin (store::transaction const & transaction_a) const
+auto nano::store::rocksdb::account::rbegin (store::transaction const & transaction_a) const -> iterator
 {
 	return store.make_iterator<nano::account, nano::account_info> (transaction_a, tables::accounts, false);
 }
 
-nano::store::iterator<nano::account, nano::account_info> nano::store::rocksdb::account::end () const
+auto nano::store::rocksdb::account::end () const -> iterator
 {
-	return store::iterator<nano::account, nano::account_info> (nullptr);
+	return iterator{ nullptr };
 }
 
-void nano::store::rocksdb::account::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::account_info>, store::iterator<nano::account, nano::account_info>)> const & action_a) const
+void nano::store::rocksdb::account::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
 {
 	parallel_traversal<nano::uint256_t> (
 	[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
diff --git a/nano/store/rocksdb/account.hpp b/nano/store/rocksdb/account.hpp
index df5752b4..1b2c068d 100644
--- a/nano/store/rocksdb/account.hpp
+++ b/nano/store/rocksdb/account.hpp
@@ -20,10 +20,10 @@ public:
 	void del (store::write_transaction const & transaction_a, nano::account const & account_a) override;
 	bool exists (store::transaction const & transaction_a, nano::account const & account_a) override;
 	size_t count (store::transaction const & transaction_a) override;
-	store::iterator<nano::account, nano::account_info> begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
-	store::iterator<nano::account, nano::account_info> begin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::account, nano::account_info> rbegin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::account, nano::account_info> end () const override;
-	void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::account_info>, store::iterator<nano::account, nano::account_info>)> const & action_a) const override;
+	iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator rbegin (store::transaction const & transaction_a) const override;
+	iterator end () const override;
+	void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
 };
 } // namespace nano::store::rocksdb
diff --git a/nano/store/rocksdb/block.cpp b/nano/store/rocksdb/block.cpp
index 10ca4067..7532193a 100644
--- a/nano/store/rocksdb/block.cpp
+++ b/nano/store/rocksdb/block.cpp
@@ -133,22 +133,23 @@ uint64_t nano::store::rocksdb::block::count (store::transaction const & transact
 {
 	return store.count (transaction_a, tables::blocks);
 }
-nano::store::iterator<nano::block_hash, nano::store::block_w_sideband> nano::store::rocksdb::block::begin (store::transaction const & transaction) const
+
+auto nano::store::rocksdb::block::begin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<nano::block_hash, nano::store::block_w_sideband> (transaction, tables::blocks);
 }
 
-nano::store::iterator<nano::block_hash, nano::store::block_w_sideband> nano::store::rocksdb::block::begin (store::transaction const & transaction, nano::block_hash const & hash) const
+auto nano::store::rocksdb::block::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
 {
 	return store.make_iterator<nano::block_hash, nano::store::block_w_sideband> (transaction, tables::blocks, hash);
 }
 
-nano::store::iterator<nano::block_hash, nano::store::block_w_sideband> nano::store::rocksdb::block::end () const
+auto nano::store::rocksdb::block::end () const -> iterator
 {
-	return store::iterator<nano::block_hash, nano::store::block_w_sideband> (nullptr);
+	return iterator{ nullptr };
 }
 
-void nano::store::rocksdb::block::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, block_w_sideband>, store::iterator<nano::block_hash, block_w_sideband>)> const & action_a) const
+void nano::store::rocksdb::block::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
 {
 	parallel_traversal<nano::uint256_t> (
 	[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
@@ -179,6 +180,7 @@ nano::block_predecessor_rocksdb_set::block_predecessor_rocksdb_set (store::write
 	block_store{ block_store_a }
 {
 }
+
 void nano::block_predecessor_rocksdb_set::fill_value (nano::block const & block_a)
 {
 	auto hash = block_a.hash ();
@@ -190,22 +192,27 @@ void nano::block_predecessor_rocksdb_set::fill_value (nano::block const & block_
 	std::copy (hash.bytes.begin (), hash.bytes.end (), data.begin () + block_store.block_successor_offset (transaction, value.size (), type));
 	block_store.raw_put (transaction, data, block_a.previous ());
 }
+
 void nano::block_predecessor_rocksdb_set::send_block (nano::send_block const & block_a)
 {
 	fill_value (block_a);
 }
+
 void nano::block_predecessor_rocksdb_set::receive_block (nano::receive_block const & block_a)
 {
 	fill_value (block_a);
 }
+
 void nano::block_predecessor_rocksdb_set::open_block (nano::open_block const & block_a)
 {
 	// Open blocks don't have a predecessor
 }
+
 void nano::block_predecessor_rocksdb_set::change_block (nano::change_block const & block_a)
 {
 	fill_value (block_a);
 }
+
 void nano::block_predecessor_rocksdb_set::state_block (nano::state_block const & block_a)
 {
 	if (!block_a.previous ().is_zero ())
diff --git a/nano/store/rocksdb/block.hpp b/nano/store/rocksdb/block.hpp
index 7df264a2..0a093f1c 100644
--- a/nano/store/rocksdb/block.hpp
+++ b/nano/store/rocksdb/block.hpp
@@ -29,10 +29,10 @@ public:
 	void del (store::write_transaction const & transaction_a, nano::block_hash const & hash_a) override;
 	bool exists (store::transaction const & transaction_a, nano::block_hash const & hash_a) override;
 	uint64_t count (store::transaction const & transaction_a) override;
-	store::iterator<nano::block_hash, nano::store::block_w_sideband> begin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::block_hash, nano::store::block_w_sideband> begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
-	store::iterator<nano::block_hash, nano::store::block_w_sideband> end () const override;
-	void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, block_w_sideband>, store::iterator<nano::block_hash, block_w_sideband>)> const & action_a) const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
+	iterator end () const override;
+	void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
 
 protected:
 	void block_raw_get (store::transaction const & transaction_a, nano::block_hash const & hash_a, nano::store::rocksdb::db_val & value) const;
diff --git a/nano/store/rocksdb/confirmation_height.cpp b/nano/store/rocksdb/confirmation_height.cpp
index 380cd80e..eea42023 100644
--- a/nano/store/rocksdb/confirmation_height.cpp
+++ b/nano/store/rocksdb/confirmation_height.cpp
@@ -59,22 +59,22 @@ void nano::store::rocksdb::confirmation_height::clear (store::write_transaction
 	store.drop (transaction, nano::tables::confirmation_height);
 }
 
-nano::store::iterator<nano::account, nano::confirmation_height_info> nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction, nano::account const & account) const
+auto nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
 {
 	return store.make_iterator<nano::account, nano::confirmation_height_info> (transaction, tables::confirmation_height, account);
 }
 
-nano::store::iterator<nano::account, nano::confirmation_height_info> nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction) const
+auto nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<nano::account, nano::confirmation_height_info> (transaction, tables::confirmation_height);
 }
 
-nano::store::iterator<nano::account, nano::confirmation_height_info> nano::store::rocksdb::confirmation_height::end () const
+auto nano::store::rocksdb::confirmation_height::end () const -> iterator
 {
-	return store::iterator<nano::account, nano::confirmation_height_info> (nullptr);
+	return iterator{ nullptr };
 }
 
-void nano::store::rocksdb::confirmation_height::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::confirmation_height_info>, store::iterator<nano::account, nano::confirmation_height_info>)> const & action_a) const
+void nano::store::rocksdb::confirmation_height::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
 {
 	parallel_traversal<nano::uint256_t> (
 	[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
diff --git a/nano/store/rocksdb/confirmation_height.hpp b/nano/store/rocksdb/confirmation_height.hpp
index 95d73004..050ceef9 100644
--- a/nano/store/rocksdb/confirmation_height.hpp
+++ b/nano/store/rocksdb/confirmation_height.hpp
@@ -21,9 +21,9 @@ public:
 	uint64_t count (store::transaction const & transaction_a) override;
 	void clear (store::write_transaction const & transaction_a, nano::account const & account_a) override;
 	void clear (store::write_transaction const & transaction_a) override;
-	store::iterator<nano::account, nano::confirmation_height_info> begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
-	store::iterator<nano::account, nano::confirmation_height_info> begin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::account, nano::confirmation_height_info> end () const override;
-	void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::confirmation_height_info>, store::iterator<nano::account, nano::confirmation_height_info>)> const & action_a) const override;
+	iterator begin (store::transaction const & transaction_a, nano::account const & account_a) const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator end () const override;
+	void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
 };
 } // namespace nano::store::rocksdb
diff --git a/nano/store/rocksdb/final_vote.cpp b/nano/store/rocksdb/final_vote.cpp
index 121da333..3979b16c 100644
--- a/nano/store/rocksdb/final_vote.cpp
+++ b/nano/store/rocksdb/final_vote.cpp
@@ -64,22 +64,22 @@ void nano::store::rocksdb::final_vote::clear (store::write_transaction const & t
 	store.drop (transaction_a, nano::tables::final_votes);
 }
 
-nano::store::iterator<nano::qualified_root, nano::block_hash> nano::store::rocksdb::final_vote::begin (store::transaction const & transaction, nano::qualified_root const & root) const
+auto nano::store::rocksdb::final_vote::begin (store::transaction const & transaction, nano::qualified_root const & root) const -> iterator
 {
 	return store.make_iterator<nano::qualified_root, nano::block_hash> (transaction, tables::final_votes, root);
 }
 
-nano::store::iterator<nano::qualified_root, nano::block_hash> nano::store::rocksdb::final_vote::begin (store::transaction const & transaction) const
+auto nano::store::rocksdb::final_vote::begin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<nano::qualified_root, nano::block_hash> (transaction, tables::final_votes);
 }
 
-nano::store::iterator<nano::qualified_root, nano::block_hash> nano::store::rocksdb::final_vote::end () const
+auto nano::store::rocksdb::final_vote::end () const -> iterator
 {
-	return store::iterator<nano::qualified_root, nano::block_hash> (nullptr);
+	return iterator{ nullptr };
 }
 
-void nano::store::rocksdb::final_vote::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::qualified_root, nano::block_hash>, store::iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const
+void nano::store::rocksdb::final_vote::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
 {
 	parallel_traversal<nano::uint512_t> (
 	[&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) {
diff --git a/nano/store/rocksdb/final_vote.hpp b/nano/store/rocksdb/final_vote.hpp
index d730ec08..a24093a5 100644
--- a/nano/store/rocksdb/final_vote.hpp
+++ b/nano/store/rocksdb/final_vote.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <nano/store/final.hpp>
+#include <nano/store/final_vote.hpp>
 
 namespace nano::store::rocksdb
 {
@@ -21,9 +21,9 @@ public:
 	size_t count (store::transaction const & transaction_a) const override;
 	void clear (store::write_transaction const & transaction_a, nano::root const & root_a) override;
 	void clear (store::write_transaction const & transaction_a) override;
-	store::iterator<nano::qualified_root, nano::block_hash> begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const override;
-	store::iterator<nano::qualified_root, nano::block_hash> begin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::qualified_root, nano::block_hash> end () const override;
-	void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::qualified_root, nano::block_hash>, store::iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const override;
+	iterator begin (store::transaction const & transaction_a, nano::qualified_root const & root_a) const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator end () const override;
+	void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
 };
 } // namespace nano::store::rocksdb
diff --git a/nano/store/rocksdb/iterator.hpp b/nano/store/rocksdb/iterator.hpp
index b661c8af..99fc9a9c 100644
--- a/nano/store/rocksdb/iterator.hpp
+++ b/nano/store/rocksdb/iterator.hpp
@@ -33,8 +33,8 @@ class iterator : public iterator_impl<T, U>
 public:
 	iterator () = default;
 
-	iterator (::rocksdb::DB * db, store::transaction const & transaction_a, ::rocksdb::ColumnFamilyHandle * handle_a, db_val const * val_a, bool const direction_asc) :
-		nano::store::iterator_impl<T, U> (transaction_a)
+	iterator (::rocksdb::DB * db, transaction const & transaction_a, ::rocksdb::ColumnFamilyHandle * handle_a, db_val const * val_a, bool const direction_asc) :
+		iterator_impl<T, U> (transaction_a)
 	{
 		// Don't fill the block cache for any blocks read as a result of an iterator
 		if (is_read (transaction_a))
@@ -79,16 +79,16 @@ public:
 	{
 	}
 
-	iterator (nano::store::rocksdb::iterator<T, U> && other_a)
+	iterator (iterator<T, U> && other_a)
 	{
 		cursor = other_a.cursor;
 		other_a.cursor = nullptr;
 		current = other_a.current;
 	}
 
-	iterator (nano::store::rocksdb::iterator<T, U> const &) = delete;
+	iterator (iterator<T, U> const &) = delete;
 
-	store::iterator_impl<T, U> & operator++ () override
+	iterator_impl<T, U> & operator++ () override
 	{
 		cursor->Next ();
 		if (cursor->Valid ())
@@ -109,7 +109,7 @@ public:
 		return *this;
 	}
 
-	store::iterator_impl<T, U> & operator-- () override
+	iterator_impl<T, U> & operator-- () override
 	{
 		cursor->Prev ();
 		if (cursor->Valid ())
@@ -135,9 +135,9 @@ public:
 		return &current;
 	}
 
-	bool operator== (store::iterator_impl<T, U> const & base_a) const override
+	bool operator== (iterator_impl<T, U> const & base_a) const override
 	{
-		auto const other_a (boost::polymorphic_downcast<nano::store::rocksdb::iterator<T, U> const *> (&base_a));
+		auto const other_a (boost::polymorphic_downcast<iterator<T, U> const *> (&base_a));
 
 		if (!current.first.data () && !other_a->current.first.data ())
 		{
@@ -187,13 +187,13 @@ public:
 		current.second = nano::store::rocksdb::db_val{};
 		debug_assert (is_end_sentinal ());
 	}
-	nano::store::rocksdb::iterator<T, U> & operator= (nano::store::rocksdb::iterator<T, U> && other_a)
+	iterator<T, U> & operator= (iterator<T, U> && other_a)
 	{
 		cursor = std::move (other_a.cursor);
 		current = other_a.current;
 		return *this;
 	}
-	store::iterator_impl<T, U> & operator= (store::iterator_impl<T, U> const &) = delete;
+	iterator_impl<T, U> & operator= (iterator_impl<T, U> const &) = delete;
 
 	std::unique_ptr<::rocksdb::Iterator> cursor;
 	std::pair<nano::store::rocksdb::db_val, nano::store::rocksdb::db_val> current;
diff --git a/nano/store/rocksdb/online_weight.cpp b/nano/store/rocksdb/online_weight.cpp
index c6f7e1da..42250c68 100644
--- a/nano/store/rocksdb/online_weight.cpp
+++ b/nano/store/rocksdb/online_weight.cpp
@@ -18,19 +18,19 @@ void nano::store::rocksdb::online_weight::del (store::write_transaction const &
 	store.release_assert_success (status);
 }
 
-nano::store::iterator<uint64_t, nano::amount> nano::store::rocksdb::online_weight::begin (store::transaction const & transaction) const
+auto nano::store::rocksdb::online_weight::begin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<uint64_t, nano::amount> (transaction, tables::online_weight);
 }
 
-nano::store::iterator<uint64_t, nano::amount> nano::store::rocksdb::online_weight::rbegin (store::transaction const & transaction) const
+auto nano::store::rocksdb::online_weight::rbegin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<uint64_t, nano::amount> (transaction, tables::online_weight, false);
 }
 
-nano::store::iterator<uint64_t, nano::amount> nano::store::rocksdb::online_weight::end () const
+auto nano::store::rocksdb::online_weight::end () const -> iterator
 {
-	return store::iterator<uint64_t, nano::amount> (nullptr);
+	return iterator{ nullptr };
 }
 
 size_t nano::store::rocksdb::online_weight::count (store::transaction const & transaction) const
diff --git a/nano/store/rocksdb/online_weight.hpp b/nano/store/rocksdb/online_weight.hpp
index 68718f3e..4d940ffd 100644
--- a/nano/store/rocksdb/online_weight.hpp
+++ b/nano/store/rocksdb/online_weight.hpp
@@ -17,9 +17,9 @@ public:
 	explicit online_weight (nano::store::rocksdb::component & store_a);
 	void put (store::write_transaction const & transaction_a, uint64_t time_a, nano::amount const & amount_a) override;
 	void del (store::write_transaction const & transaction_a, uint64_t time_a) override;
-	store::iterator<uint64_t, nano::amount> begin (store::transaction const & transaction_a) const override;
-	store::iterator<uint64_t, nano::amount> rbegin (store::transaction const & transaction_a) const override;
-	store::iterator<uint64_t, nano::amount> end () const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator rbegin (store::transaction const & transaction_a) const override;
+	iterator end () const override;
 	size_t count (store::transaction const & transaction_a) const override;
 	void clear (store::write_transaction const & transaction_a) override;
 };
diff --git a/nano/store/rocksdb/peer.cpp b/nano/store/rocksdb/peer.cpp
index af226e8a..71fa3ccc 100644
--- a/nano/store/rocksdb/peer.cpp
+++ b/nano/store/rocksdb/peer.cpp
@@ -45,12 +45,12 @@ void nano::store::rocksdb::peer::clear (store::write_transaction const & transac
 	store.release_assert_success (status);
 }
 
-nano::store::iterator<nano::endpoint_key, nano::millis_t> nano::store::rocksdb::peer::begin (store::transaction const & transaction) const
+auto nano::store::rocksdb::peer::begin (store::transaction const & transaction) const -> iterator
 {
 	return store.make_iterator<nano::endpoint_key, nano::millis_t> (transaction, tables::peers);
 }
 
-nano::store::iterator<nano::endpoint_key, nano::millis_t> nano::store::rocksdb::peer::end () const
+auto nano::store::rocksdb::peer::end () const -> iterator
 {
-	return store::iterator<nano::endpoint_key, nano::millis_t> (nullptr);
+	return iterator{ nullptr };
 }
diff --git a/nano/store/rocksdb/peer.hpp b/nano/store/rocksdb/peer.hpp
index a4ce7286..30e57644 100644
--- a/nano/store/rocksdb/peer.hpp
+++ b/nano/store/rocksdb/peer.hpp
@@ -21,7 +21,7 @@ public:
 	bool exists (store::transaction const &, nano::endpoint_key const & endpoint) const override;
 	size_t count (store::transaction const &) const override;
 	void clear (store::write_transaction const &) override;
-	store::iterator<nano::endpoint_key, nano::millis_t> begin (store::transaction const &) const override;
-	store::iterator<nano::endpoint_key, nano::millis_t> end () const override;
+	iterator begin (store::transaction const &) const override;
+	iterator end () const override;
 };
 } // namespace nano::store::rocksdb
diff --git a/nano/store/rocksdb/pending.cpp b/nano/store/rocksdb/pending.cpp
index 27efe5e6..3286cd8f 100644
--- a/nano/store/rocksdb/pending.cpp
+++ b/nano/store/rocksdb/pending.cpp
@@ -45,22 +45,22 @@ bool nano::store::rocksdb::pending::any (store::transaction const & transaction_
 	return iterator != end () && nano::pending_key (iterator->first).account == account_a;
 }
 
-nano::store::iterator<nano::pending_key, nano::pending_info> nano::store::rocksdb::pending::begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const
+auto nano::store::rocksdb::pending::begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const -> iterator
 {
 	return store.template make_iterator<nano::pending_key, nano::pending_info> (transaction_a, tables::pending, key_a);
 }
 
-nano::store::iterator<nano::pending_key, nano::pending_info> nano::store::rocksdb::pending::begin (store::transaction const & transaction_a) const
+auto nano::store::rocksdb::pending::begin (store::transaction const & transaction_a) const -> iterator
 {
 	return store.template make_iterator<nano::pending_key, nano::pending_info> (transaction_a, tables::pending);
 }
 
-nano::store::iterator<nano::pending_key, nano::pending_info> nano::store::rocksdb::pending::end () const
+auto nano::store::rocksdb::pending::end () const -> iterator
 {
-	return store::iterator<nano::pending_key, nano::pending_info> (nullptr);
+	return iterator{ nullptr };
 }
 
-void nano::store::rocksdb::pending::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::pending_key, nano::pending_info>, store::iterator<nano::pending_key, nano::pending_info>)> const & action_a) const
+void nano::store::rocksdb::pending::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
 {
 	parallel_traversal<nano::uint512_t> (
 	[&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) {
diff --git a/nano/store/rocksdb/pending.hpp b/nano/store/rocksdb/pending.hpp
index 0ee4ced5..4b98b0f0 100644
--- a/nano/store/rocksdb/pending.hpp
+++ b/nano/store/rocksdb/pending.hpp
@@ -16,9 +16,9 @@ public:
 	std::optional<nano::pending_info> get (store::transaction const & transaction_a, nano::pending_key const & key_a) override;
 	bool exists (store::transaction const & transaction_a, nano::pending_key const & key_a) override;
 	bool any (store::transaction const & transaction_a, nano::account const & account_a) override;
-	store::iterator<nano::pending_key, nano::pending_info> begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const override;
-	store::iterator<nano::pending_key, nano::pending_info> begin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::pending_key, nano::pending_info> end () const override;
-	void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::pending_key, nano::pending_info>, store::iterator<nano::pending_key, nano::pending_info>)> const & action_a) const override;
+	iterator begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator end () const override;
+	void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
 };
 } // namespace nano::store::rocksdb
diff --git a/nano/store/rocksdb/pruned.cpp b/nano/store/rocksdb/pruned.cpp
index 41d7fbb5..572f17e3 100644
--- a/nano/store/rocksdb/pruned.cpp
+++ b/nano/store/rocksdb/pruned.cpp
@@ -45,22 +45,22 @@ void nano::store::rocksdb::pruned::clear (store::write_transaction const & trans
 	store.release_assert_success (status);
 }
 
-nano::store::iterator<nano::block_hash, std::nullptr_t> nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const
+auto nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const -> iterator
 {
 	return store.make_iterator<nano::block_hash, std::nullptr_t> (transaction_a, tables::pruned, hash_a);
 }
 
-nano::store::iterator<nano::block_hash, std::nullptr_t> nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a) const
+auto nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a) const -> iterator
 {
 	return store.make_iterator<nano::block_hash, std::nullptr_t> (transaction_a, tables::pruned);
 }
 
-nano::store::iterator<nano::block_hash, std::nullptr_t> nano::store::rocksdb::pruned::end () const
+auto nano::store::rocksdb::pruned::end () const -> iterator
 {
-	return store::iterator<nano::block_hash, std::nullptr_t> (nullptr);
+	return iterator{ nullptr };
 }
 
-void nano::store::rocksdb::pruned::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, std::nullptr_t>, store::iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const
+void nano::store::rocksdb::pruned::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
 {
 	parallel_traversal<nano::uint256_t> (
 	[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
diff --git a/nano/store/rocksdb/pruned.hpp b/nano/store/rocksdb/pruned.hpp
index aa5db1fb..0dc84b84 100644
--- a/nano/store/rocksdb/pruned.hpp
+++ b/nano/store/rocksdb/pruned.hpp
@@ -21,9 +21,9 @@ public:
 	nano::block_hash random (store::transaction const & transaction_a) override;
 	size_t count (store::transaction const & transaction_a) const override;
 	void clear (store::write_transaction const & transaction_a) override;
-	store::iterator<nano::block_hash, std::nullptr_t> begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
-	store::iterator<nano::block_hash, std::nullptr_t> begin (store::transaction const & transaction_a) const override;
-	store::iterator<nano::block_hash, std::nullptr_t> end () const override;
-	void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::block_hash, std::nullptr_t>, store::iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const override;
+	iterator begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
+	iterator begin (store::transaction const & transaction_a) const override;
+	iterator end () const override;
+	void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
 };
 } // namespace nano::store::rocksdb
diff --git a/nano/store/rocksdb/rep_weight.cpp b/nano/store/rocksdb/rep_weight.cpp
index 7f29e61e..68d4684c 100644
--- a/nano/store/rocksdb/rep_weight.cpp
+++ b/nano/store/rocksdb/rep_weight.cpp
@@ -42,26 +42,26 @@ void nano::store::rocksdb::rep_weight::del (store::write_transaction const & txn
 	store.release_assert_success (status);
 }
 
-nano::store::iterator<nano::account, nano::uint128_union> nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a, nano::account const & representative_a) const
+auto nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a, nano::account const & representative_a) const -> iterator
 {
 	return store.make_iterator<nano::account, nano::uint128_union> (txn_a, tables::rep_weights, representative_a);
 }
 
-nano::store::iterator<nano::account, nano::uint128_union> nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a) const
+auto nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a) const -> iterator
 {
 	return store.make_iterator<nano::account, nano::uint128_union> (txn_a, tables::rep_weights);
 }
 
-nano::store::iterator<nano::account, nano::uint128_union> nano::store::rocksdb::rep_weight::end () const
+auto nano::store::rocksdb::rep_weight::end () const -> iterator
 {
-	return store::iterator<nano::account, nano::uint128_union> (nullptr);
+	return iterator{ nullptr };
 }
 
-void nano::store::rocksdb::rep_weight::for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::uint128_union>, store::iterator<nano::account, nano::uint128_union>)> const & action_a) const
+void nano::store::rocksdb::rep_weight::for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const
 {
 	parallel_traversal<nano::uint256_t> (
 	[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
 		auto transaction (this->store.tx_begin_read ());
 		action_a (transaction, this->begin (transaction, start), !is_last ? this->begin (transaction, end) : this->end ());
 	});
-}
\ No newline at end of file
+}
diff --git a/nano/store/rocksdb/rep_weight.hpp b/nano/store/rocksdb/rep_weight.hpp
index c86f2715..76e54226 100644
--- a/nano/store/rocksdb/rep_weight.hpp
+++ b/nano/store/rocksdb/rep_weight.hpp
@@ -19,9 +19,9 @@ public:
 	nano::uint128_t get (store::transaction const & txn_a, nano::account const & representative_a) override;
 	void put (store::write_transaction const & txn_a, nano::account const & representative_a, nano::uint128_t const & weight_a) override;
 	void del (store::write_transaction const &, nano::account const & representative_a) override;
-	store::iterator<nano::account, nano::uint128_union> begin (store::transaction const & txn_a, nano::account const & representative_a) const override;
-	store::iterator<nano::account, nano::uint128_union> begin (store::transaction const & txn_a) const override;
-	store::iterator<nano::account, nano::uint128_union> end () const override;
-	void for_each_par (std::function<void (store::read_transaction const &, store::iterator<nano::account, nano::uint128_union>, store::iterator<nano::account, nano::uint128_union>)> const & action_a) const override;
+	iterator begin (store::transaction const & txn_a, nano::account const & representative_a) const override;
+	iterator begin (store::transaction const & txn_a) const override;
+	iterator end () const override;
+	void for_each_par (std::function<void (store::read_transaction const &, iterator, iterator)> const & action_a) const override;
 };
 }
diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp
index c0a9831c..40f8be22 100644
--- a/nano/test_common/system.cpp
+++ b/nano/test_common/system.cpp
@@ -532,7 +532,7 @@ void nano::test::system::generate_send_existing (nano::node & node_a, std::vecto
 		nano::account account;
 		random_pool::generate_block (account.bytes.data (), sizeof (account.bytes));
 		auto transaction = node_a.ledger.tx_begin_read ();
-		store::iterator<nano::account, nano::account_info> entry (node_a.store.account.begin (transaction, account));
+		auto entry = node_a.store.account.begin (transaction, account);
 		if (entry == node_a.store.account.end ())
 		{
 			entry = node_a.store.account.begin (transaction);