diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp
index 8908d70c..4f81bf23 100644
--- a/nano/core_test/node.cpp
+++ b/nano/core_test/node.cpp
@@ -3046,7 +3046,7 @@ TEST (node, epoch_conflict_confirm)
 	             .work (*system.work.generate (send->hash ()))
 	             .build_shared ();
 	auto epoch_open = builder.make_block ()
-	                  .account (change->root ())
+	                  .account (change->root ().as_account ())
 	                  .previous (0)
 	                  .representative (0)
 	                  .balance (0)
diff --git a/nano/lib/numbers.cpp b/nano/lib/numbers.cpp
index 2b83972b..f4f771c8 100644
--- a/nano/lib/numbers.cpp
+++ b/nano/lib/numbers.cpp
@@ -830,12 +830,12 @@ std::string nano::hash_or_account::to_account () const
 	return account.to_account ();
 }
 
-nano::hash_or_account::operator nano::block_hash const & () const
+nano::block_hash const & nano::hash_or_account::as_block_hash () const
 {
 	return hash;
 }
 
-nano::hash_or_account::operator nano::account const & () const
+nano::account const & nano::hash_or_account::as_account () const
 {
 	return account;
 }
diff --git a/nano/lib/numbers.hpp b/nano/lib/numbers.hpp
index 3e84d022..59f294b7 100644
--- a/nano/lib/numbers.hpp
+++ b/nano/lib/numbers.hpp
@@ -147,8 +147,9 @@ public:
 	bool decode_account (std::string const &);
 	std::string to_account () const;
 
-	operator nano::block_hash const & () const;
-	operator nano::account const & () const;
+	nano::account const & as_account () const;
+	nano::block_hash const & as_block_hash () const;
+
 	operator nano::uint256_union const & () const;
 
 	bool operator== (nano::hash_or_account const &) const;
diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp
index 3906b468..3e54cda9 100644
--- a/nano/nano_node/entry.cpp
+++ b/nano/nano_node/entry.cpp
@@ -959,7 +959,7 @@ int main (int argc, char * const * argv)
 
 					auto send = builder.state ()
 					            .account (keys[j].pub)
-					            .previous (frontiers[j])
+					            .previous (frontiers[j].as_block_hash ())
 					            .representative (keys[j].pub)
 					            .balance (balances[j])
 					            .link (keys[other].pub)
@@ -974,10 +974,10 @@ int main (int argc, char * const * argv)
 
 					auto receive = builder.state ()
 					               .account (keys[other].pub)
-					               .previous (frontiers[other])
+					               .previous (frontiers[other].as_block_hash ())
 					               .representative (keys[other].pub)
 					               .balance (balances[other])
-					               .link (static_cast<nano::block_hash const &> (frontiers[j]))
+					               .link (frontiers[j].as_block_hash ())
 					               .sign (keys[other].prv, keys[other].pub)
 					               .work (*work.generate (nano::work_version::work_1, frontiers[other], node->network_params.network.publish_thresholds.epoch_1))
 					               .build ();
@@ -1529,7 +1529,7 @@ int main (int argc, char * const * argv)
 							{
 								// State receive
 								block_details_error = !sideband.details.is_receive || sideband.details.is_send || sideband.details.is_epoch;
-								block_details_error |= !node->store.block_exists (transaction, block->link ());
+								block_details_error |= !node->store.block_exists (transaction, block->link ().as_block_hash ());
 							}
 						}
 					}
@@ -1540,7 +1540,7 @@ int main (int argc, char * const * argv)
 					// Check link epoch version
 					if (sideband.details.is_receive)
 					{
-						if (sideband.source_epoch != node->store.block_version (transaction, block->link ()))
+						if (sideband.source_epoch != node->store.block_version (transaction, block->link ().as_block_hash ()))
 						{
 							print_error_message (boost::str (boost::format ("Incorrect source epoch for block %1%\n") % hash.to_string ()));
 						}
@@ -1666,7 +1666,7 @@ int main (int argc, char * const * argv)
 					{
 						if (node->ledger.is_send (transaction, *state))
 						{
-							destination = state->hashables.link;
+							destination = state->hashables.link.as_account ();
 						}
 					}
 					else if (auto send = dynamic_cast<nano::send_block *> (block.get ()))
diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp
index 7f17207f..6e3c1033 100644
--- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp
+++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp
@@ -435,20 +435,20 @@ void nano::bulk_pull_server::set_current_end ()
 		request->end.clear ();
 	}
 
-	if (connection->node->store.block_exists (transaction, request->start))
+	if (connection->node->store.block_exists (transaction, request->start.as_block_hash ()))
 	{
 		if (connection->node->config.logging.bulk_pull_logging ())
 		{
 			connection->node->logger.try_log (boost::str (boost::format ("Bulk pull request for block hash: %1%") % request->start.to_string ()));
 		}
 
-		current = request->start;
+		current = request->start.as_block_hash ();
 		include_start = true;
 	}
 	else
 	{
 		nano::account_info info;
-		auto no_address (connection->node->store.account_get (transaction, request->start, info));
+		auto no_address (connection->node->store.account_get (transaction, request->start.as_account (), info));
 		if (no_address)
 		{
 			if (connection->node->config.logging.bulk_pull_logging ())
diff --git a/nano/node/bootstrap/bootstrap_connections.cpp b/nano/node/bootstrap/bootstrap_connections.cpp
index 80fd2d72..2dce9181 100644
--- a/nano/node/bootstrap/bootstrap_connections.cpp
+++ b/nano/node/bootstrap/bootstrap_connections.cpp
@@ -416,7 +416,7 @@ void nano::bootstrap_connections::requeue_pull (nano::pull_info const & pull_a,
 		else if (attempt_l->mode == nano::bootstrap_mode::lazy && (pull.retry_limit == std::numeric_limits<unsigned>::max () || pull.attempts <= pull.retry_limit + (pull.processed / node.network_params.bootstrap.lazy_max_pull_blocks)))
 		{
 			debug_assert (pull.account_or_head == pull.head);
-			if (!attempt_l->lazy_processed_or_exists (pull.account_or_head))
+			if (!attempt_l->lazy_processed_or_exists (pull.account_or_head.as_block_hash ()))
 			{
 				{
 					nano::lock_guard<std::mutex> lock (mutex);
diff --git a/nano/node/bootstrap/bootstrap_lazy.cpp b/nano/node/bootstrap/bootstrap_lazy.cpp
index ef1dc82e..4bf192fc 100644
--- a/nano/node/bootstrap/bootstrap_lazy.cpp
+++ b/nano/node/bootstrap/bootstrap_lazy.cpp
@@ -31,9 +31,9 @@ void nano::bootstrap_attempt_lazy::lazy_start (nano::hash_or_account const & has
 	nano::unique_lock<std::mutex> lock (mutex);
 	// Add start blocks, limit 1024 (4k with disabled legacy bootstrap)
 	size_t max_keys (node->flags.disable_legacy_bootstrap ? 4 * 1024 : 1024);
-	if (lazy_keys.size () < max_keys && lazy_keys.find (hash_or_account_a) == lazy_keys.end () && !lazy_blocks_processed (hash_or_account_a))
+	if (lazy_keys.size () < max_keys && lazy_keys.find (hash_or_account_a.as_block_hash ()) == lazy_keys.end () && !lazy_blocks_processed (hash_or_account_a.as_block_hash ()))
 	{
-		lazy_keys.insert (hash_or_account_a);
+		lazy_keys.insert (hash_or_account_a.as_block_hash ());
 		lazy_pulls.emplace_back (hash_or_account_a, confirmed ? std::numeric_limits<unsigned>::max () : node->network_params.bootstrap.lazy_retry_limit);
 		lock.unlock ();
 		condition.notify_all ();
@@ -44,7 +44,7 @@ void nano::bootstrap_attempt_lazy::lazy_add (nano::hash_or_account const & hash_
 {
 	// Add only unknown blocks
 	debug_assert (!mutex.try_lock ());
-	if (!lazy_blocks_processed (hash_or_account_a))
+	if (!lazy_blocks_processed (hash_or_account_a.as_block_hash ()))
 	{
 		lazy_pulls.emplace_back (hash_or_account_a, retry_limit);
 	}
@@ -103,10 +103,10 @@ void nano::bootstrap_attempt_lazy::lazy_pull_flush (nano::unique_lock<std::mutex
 			auto pull_start (lazy_pulls.front ());
 			lazy_pulls.pop_front ();
 			// Recheck if block was already processed
-			if (!lazy_blocks_processed (pull_start.first) && !node->store.block_exists (transaction, pull_start.first))
+			if (!lazy_blocks_processed (pull_start.first.as_block_hash ()) && !node->store.block_exists (transaction, pull_start.first.as_block_hash ()))
 			{
 				lock_a.unlock ();
-				node->bootstrap_initiator.connections->add_pull (nano::pull_info (pull_start.first, pull_start.first, nano::block_hash (0), incremental_id, batch_count, pull_start.second));
+				node->bootstrap_initiator.connections->add_pull (nano::pull_info (pull_start.first, pull_start.first.as_block_hash (), nano::block_hash (0), incremental_id, batch_count, pull_start.second));
 				++pulling;
 				++count;
 				lock_a.lock ();
@@ -300,7 +300,7 @@ void nano::bootstrap_attempt_lazy::lazy_block_state (std::shared_ptr<nano::block
 		nano::uint128_t balance (block_l->hashables.balance.number ());
 		auto const & link (block_l->hashables.link);
 		// If link is not epoch link or 0. And if block from link is unknown
-		if (!link.is_zero () && !node->ledger.is_epoch_link (link) && !lazy_blocks_processed (link) && !node->store.block_exists (transaction, link))
+		if (!link.is_zero () && !node->ledger.is_epoch_link (link) && !lazy_blocks_processed (link.as_block_hash ()) && !node->store.block_exists (transaction, link.as_block_hash ()))
 		{
 			auto const & previous (block_l->hashables.previous);
 			// If state block previous is 0 then source block required
@@ -317,7 +317,7 @@ void nano::bootstrap_attempt_lazy::lazy_block_state (std::shared_ptr<nano::block
 				}
 				else
 				{
-					lazy_destinations_increment (link);
+					lazy_destinations_increment (link.as_account ());
 				}
 			}
 			// Search balance of already processed previous blocks
@@ -332,7 +332,7 @@ void nano::bootstrap_attempt_lazy::lazy_block_state (std::shared_ptr<nano::block
 					}
 					else
 					{
-						lazy_destinations_increment (link);
+						lazy_destinations_increment (link.as_account ());
 					}
 					lazy_balances.erase (previous_balance);
 				}
@@ -362,14 +362,14 @@ void nano::bootstrap_attempt_lazy::lazy_block_state_backlog_check (std::shared_p
 			}
 			else
 			{
-				lazy_destinations_increment (next_block.link);
+				lazy_destinations_increment (next_block.link.as_account ());
 			}
 		}
 		// Assumption for other legacy block types
-		else if (lazy_undefined_links.find (next_block.link) == lazy_undefined_links.end ())
+		else if (lazy_undefined_links.find (next_block.link.as_block_hash ()) == lazy_undefined_links.end ())
 		{
 			lazy_add (next_block.link, node->network_params.bootstrap.lazy_retry_limit); // Head is not confirmed. It can be account or hash or non-existing
-			lazy_undefined_links.insert (next_block.link);
+			lazy_undefined_links.insert (next_block.link.as_block_hash ());
 		}
 		lazy_state_backlog.erase (find_state);
 	}
@@ -390,7 +390,7 @@ void nano::bootstrap_attempt_lazy::lazy_backlog_cleanup ()
 			}
 			else
 			{
-				lazy_destinations_increment (next_block.link);
+				lazy_destinations_increment (next_block.link.as_account ());
 			}
 			it = lazy_state_backlog.erase (it);
 		}
diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp
index f3347b23..365709ef 100644
--- a/nano/node/confirmation_height_bounded.cpp
+++ b/nano/node/confirmation_height_bounded.cpp
@@ -241,7 +241,7 @@ bool nano::confirmation_height_bounded::iterate (nano::read_transaction const &
 		auto source (block->source ());
 		if (source.is_zero ())
 		{
-			source = block->link ();
+			source = block->link ().as_block_hash ();
 		}
 
 		if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.store.block_exists (transaction_a, source))
diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp
index 85b905b2..1fb12cbc 100644
--- a/nano/node/confirmation_height_unbounded.cpp
+++ b/nano/node/confirmation_height_unbounded.cpp
@@ -191,7 +191,7 @@ void nano::confirmation_height_unbounded::collect_unconfirmed_receive_and_source
 			auto source (block->source ());
 			if (source.is_zero ())
 			{
-				source = block->link ();
+				source = block->link ().as_block_hash ();
 			}
 
 			if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.store.block_exists (transaction_a, source))
diff --git a/nano/node/distributed_work.cpp b/nano/node/distributed_work.cpp
index dd315c5d..161668b3 100644
--- a/nano/node/distributed_work.cpp
+++ b/nano/node/distributed_work.cpp
@@ -43,15 +43,15 @@ nano::distributed_work::~distributed_work ()
 			nano::websocket::message_builder builder;
 			if (status == work_generation_status::success)
 			{
-				node_l->websocket_server->broadcast (builder.work_generation (request.version, request.root, work_result, request.difficulty, node_l->default_difficulty (request.version), elapsed.value (), winner, bad_peers));
+				node_l->websocket_server->broadcast (builder.work_generation (request.version, request.root.as_block_hash (), work_result, request.difficulty, node_l->default_difficulty (request.version), elapsed.value (), winner, bad_peers));
 			}
 			else if (status == work_generation_status::cancelled)
 			{
-				node_l->websocket_server->broadcast (builder.work_cancelled (request.version, request.root, request.difficulty, node_l->default_difficulty (request.version), elapsed.value (), bad_peers));
+				node_l->websocket_server->broadcast (builder.work_cancelled (request.version, request.root.as_block_hash (), request.difficulty, node_l->default_difficulty (request.version), elapsed.value (), bad_peers));
 			}
 			else if (status == work_generation_status::failure_local || status == work_generation_status::failure_peers)
 			{
-				node_l->websocket_server->broadcast (builder.work_failed (request.version, request.root, request.difficulty, node_l->default_difficulty (request.version), elapsed.value (), bad_peers));
+				node_l->websocket_server->broadcast (builder.work_failed (request.version, request.root.as_block_hash (), request.difficulty, node_l->default_difficulty (request.version), elapsed.value (), bad_peers));
 			}
 		}
 		stop_once (true);
diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp
index e3b0e973..0eff29f5 100644
--- a/nano/node/json_handler.cpp
+++ b/nano/node/json_handler.cpp
@@ -394,8 +394,8 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a)
 	auto link (block_a.link ());
 	if (!link.is_zero () && !details.is_send)
 	{
-		auto block_link (node.store.block_get (transaction, link));
-		if (block_link != nullptr && node.store.pending_exists (transaction, nano::pending_key (block_a.account (), link)))
+		auto block_link (node.store.block_get (transaction, link.as_block_hash ()));
+		if (block_link != nullptr && node.store.pending_exists (transaction, nano::pending_key (block_a.account (), link.as_block_hash ())))
 		{
 			details.epoch = std::max (details.epoch, block_link->sideband ().details.epoch);
 			details.is_receive = true;
@@ -2246,7 +2246,7 @@ public:
 		auto previous_balance (handler.node.ledger.balance (transaction, block_a.hashables.previous));
 		if (balance < previous_balance)
 		{
-			if (should_ignore_account (block_a.hashables.link))
+			if (should_ignore_account (block_a.hashables.link.as_account ()))
 			{
 				tree.clear ();
 				return;
@@ -2281,7 +2281,7 @@ public:
 			}
 			else
 			{
-				auto account (handler.node.ledger.account (transaction, block_a.hashables.link));
+				auto account (handler.node.ledger.account (transaction, block_a.hashables.link.as_block_hash ()));
 				if (should_ignore_account (account))
 				{
 					tree.clear ();
diff --git a/nano/node/lmdb/lmdb.cpp b/nano/node/lmdb/lmdb.cpp
index 36f063af..405eeb96 100644
--- a/nano/node/lmdb/lmdb.cpp
+++ b/nano/node/lmdb/lmdb.cpp
@@ -673,7 +673,7 @@ void nano::mdb_store::upgrade_v18_to_v19 (nano::write_transaction const & transa
 			// Source block v18 epoch
 			if (old_sideband.details.is_receive)
 			{
-				auto db_val (block_raw_get_by_type_v18 (transaction_a, block_w_sideband_v18.block->link (), type_state));
+				auto db_val (block_raw_get_by_type_v18 (transaction_a, block_w_sideband_v18.block->link ().as_block_hash (), type_state));
 				if (db_val.is_initialized ())
 				{
 					nano::bufferstream stream (reinterpret_cast<uint8_t const *> (db_val.get ().data ()), db_val.get ().size ());
diff --git a/nano/node/node.cpp b/nano/node/node.cpp
index 55f90d33..7fd61f63 100644
--- a/nano/node/node.cpp
+++ b/nano/node/node.cpp
@@ -536,13 +536,13 @@ void nano::node::process_fork (nano::transaction const & transaction_a, std::sha
 						nano::account account{ 0 };
 						if (root_block_type == nano::block_type::receive || root_block_type == nano::block_type::send || root_block_type == nano::block_type::change || root_block_type == nano::block_type::open)
 						{
-							account = this_l->ledger.store.frontier_get (transaction, root);
+							account = this_l->ledger.store.frontier_get (transaction, root.as_block_hash ());
 						}
 						if (!account.is_zero ())
 						{
-							this_l->bootstrap_initiator.connections->requeue_pull (nano::pull_info (account, root, root, attempt->incremental_id));
+							this_l->bootstrap_initiator.connections->requeue_pull (nano::pull_info (account, root.as_block_hash (), root.as_block_hash (), attempt->incremental_id));
 						}
-						else if (this_l->ledger.store.account_exists (transaction, root))
+						else if (this_l->ledger.store.account_exists (transaction, root.as_account ()))
 						{
 							this_l->bootstrap_initiator.connections->requeue_pull (nano::pull_info (root, nano::block_hash (0), nano::block_hash (0), attempt->incremental_id));
 						}
@@ -1211,7 +1211,7 @@ public:
 	}
 	void state_block (nano::state_block const & block_a) override
 	{
-		scan_receivable (block_a.hashables.link);
+		scan_receivable (block_a.hashables.link.as_account ());
 	}
 	void send_block (nano::send_block const & block_a) override
 	{
@@ -1265,7 +1265,7 @@ void nano::node::process_confirmed_data (nano::transaction const & transaction_a
 		{
 			is_state_send_a = true;
 		}
-		pending_account_a = state->hashables.link;
+		pending_account_a = state->hashables.link.as_account ();
 	}
 	if (auto send = dynamic_cast<nano::send_block *> (block_a.get ()))
 	{
diff --git a/nano/node/request_aggregator.cpp b/nano/node/request_aggregator.cpp
index 92f1c381..28af292b 100644
--- a/nano/node/request_aggregator.cpp
+++ b/nano/node/request_aggregator.cpp
@@ -174,12 +174,12 @@ std::vector<std::pair<nano::root, nano::block_hash>> nano::request_aggregator::a
 			if (block == nullptr && !hash_root.second.is_zero ())
 			{
 				// Search for block root
-				auto successor (ledger.store.block_successor (transaction_a, hash_root.second));
+				auto successor (ledger.store.block_successor (transaction_a, hash_root.second.as_block_hash ()));
 				// Search for account root
 				if (successor.is_zero ())
 				{
 					nano::account_info info;
-					auto error (ledger.store.account_get (transaction_a, hash_root.second, info));
+					auto error (ledger.store.account_get (transaction_a, hash_root.second.as_account (), info));
 					if (!error)
 					{
 						successor = info.open_block;
diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp
index 22d145c1..c8375e89 100644
--- a/nano/qt/qt.cpp
+++ b/nano/qt/qt.cpp
@@ -559,7 +559,7 @@ public:
 		{
 			type = "Send";
 			amount = previous_balance - balance;
-			account = block_a.hashables.link;
+			account = block_a.hashables.link.as_account ();
 		}
 		else
 		{
@@ -576,7 +576,7 @@ public:
 			else
 			{
 				type = "Receive";
-				account = ledger.account (transaction, block_a.hashables.link);
+				account = ledger.account (transaction, block_a.hashables.link.as_block_hash ());
 			}
 			amount = balance - previous_balance;
 		}
diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp
index 66508db9..076acaae 100644
--- a/nano/rpc_test/rpc.cpp
+++ b/nano/rpc_test/rpc.cpp
@@ -2820,7 +2820,7 @@ TEST (rpc, work_generate_block_high)
 	rpc.start ();
 	nano::keypair key;
 	nano::state_block block (key.pub, 0, nano::dev_genesis_key.pub, nano::Gxrb_ratio, 123, key.prv, key.pub, *node->work_generate_blocking (key.pub));
-	nano::block_hash hash (block.root ());
+	nano::block_hash hash (block.root ().as_block_hash ());
 	auto block_difficulty (nano::work_difficulty (nano::work_version::work_1, hash, block.block_work ()));
 	boost::property_tree::ptree request;
 	request.put ("action", "work_generate");
@@ -2853,8 +2853,8 @@ TEST (rpc, work_generate_block_low)
 	nano::keypair key;
 	nano::state_block block (key.pub, 0, nano::dev_genesis_key.pub, nano::Gxrb_ratio, 123, key.prv, key.pub, 0);
 	auto threshold (node->default_difficulty (block.work_version ()));
-	block.block_work_set (system.work_generate_limited (block.root (), threshold, nano::difficulty::from_multiplier (node->config.max_work_generate_multiplier / 10, threshold)));
-	nano::block_hash hash (block.root ());
+	block.block_work_set (system.work_generate_limited (block.root ().as_block_hash (), threshold, nano::difficulty::from_multiplier (node->config.max_work_generate_multiplier / 10, threshold)));
+	nano::block_hash hash (block.root ().as_block_hash ());
 	auto block_difficulty (block.difficulty ());
 	boost::property_tree::ptree request;
 	request.put ("action", "work_generate");
@@ -2935,8 +2935,8 @@ TEST (rpc, work_generate_block_ledger_epoch_2)
 	rpc.start ();
 	nano::state_block block (key.pub, 0, nano::dev_genesis_key.pub, nano::Gxrb_ratio, send_block->hash (), key.prv, key.pub, 0);
 	auto threshold (nano::work_threshold (block.work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false)));
-	block.block_work_set (system.work_generate_limited (block.root (), 1, threshold - 1));
-	nano::block_hash hash (block.root ());
+	block.block_work_set (system.work_generate_limited (block.root ().as_block_hash (), 1, threshold - 1));
+	nano::block_hash hash (block.root ().as_block_hash ());
 	boost::property_tree::ptree request;
 	request.put ("action", "work_generate");
 	request.put ("hash", hash.to_string ());
diff --git a/nano/secure/blockstore_partial.hpp b/nano/secure/blockstore_partial.hpp
index 60b91bd5..5084901f 100644
--- a/nano/secure/blockstore_partial.hpp
+++ b/nano/secure/blockstore_partial.hpp
@@ -155,7 +155,7 @@ public:
 
 	bool root_exists (nano::transaction const & transaction_a, nano::root const & root_a) override
 	{
-		return block_exists (transaction_a, root_a) || account_exists (transaction_a, root_a);
+		return block_exists (transaction_a, root_a.as_block_hash ()) || account_exists (transaction_a, root_a.as_account ());
 	}
 
 	nano::account block_account (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override
diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp
index 344acda3..65949a2d 100644
--- a/nano/secure/ledger.cpp
+++ b/nano/secure/ledger.cpp
@@ -133,18 +133,18 @@ public:
 
 		if (is_send)
 		{
-			nano::pending_key key (block_a.hashables.link, hash);
+			nano::pending_key key (block_a.hashables.link.as_account (), hash);
 			while (!error && !ledger.store.pending_exists (transaction, key))
 			{
-				error = ledger.rollback (transaction, ledger.latest (transaction, block_a.hashables.link), list);
+				error = ledger.rollback (transaction, ledger.latest (transaction, block_a.hashables.link.as_account ()), list);
 			}
 			ledger.store.pending_del (transaction, key);
 			ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::send);
 		}
 		else if (!block_a.hashables.link.is_zero () && !ledger.is_epoch_link (block_a.hashables.link))
 		{
-			nano::pending_info pending_info (ledger.account (transaction, block_a.hashables.link), block_a.hashables.balance.number () - balance, block_a.sideband ().source_epoch);
-			ledger.store.pending_put (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link), pending_info);
+			nano::pending_info pending_info (ledger.account (transaction, block_a.hashables.link.as_block_hash ()), block_a.hashables.balance.number () - balance, block_a.sideband ().source_epoch);
+			ledger.store.pending_put (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link.as_block_hash ()), pending_info);
 			ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::receive);
 		}
 
@@ -316,10 +316,10 @@ void ledger_processor::state_block_impl (nano::state_block & block_a)
 					{
 						if (!block_a.hashables.link.is_zero ())
 						{
-							result.code = ledger.store.block_exists (transaction, block_a.hashables.link) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block already? (Harmless)
+							result.code = ledger.store.block_exists (transaction, block_a.hashables.link.as_block_hash ()) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block already? (Harmless)
 							if (result.code == nano::process_result::progress)
 							{
-								nano::pending_key key (block_a.hashables.account, block_a.hashables.link);
+								nano::pending_key key (block_a.hashables.account, block_a.hashables.link.as_block_hash ());
 								nano::pending_info pending;
 								result.code = ledger.store.pending_get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed)
 								if (result.code == nano::process_result::progress)
@@ -360,13 +360,13 @@ void ledger_processor::state_block_impl (nano::state_block & block_a)
 
 						if (is_send)
 						{
-							nano::pending_key key (block_a.hashables.link, hash);
+							nano::pending_key key (block_a.hashables.link.as_account (), hash);
 							nano::pending_info info (block_a.hashables.account, amount.number (), epoch);
 							ledger.store.pending_put (transaction, key, info);
 						}
 						else if (!block_a.hashables.link.is_zero ())
 						{
-							ledger.store.pending_del (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link));
+							ledger.store.pending_del (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link.as_block_hash ()));
 						}
 
 						nano::account_info new_info (hash, block_a.representative (), info.open_block.is_zero () ? hash : info.open_block, block_a.hashables.balance, nano::seconds_since_epoch (), info.block_count + 1, epoch);
@@ -883,7 +883,7 @@ nano::account const & nano::ledger::block_destination (nano::transaction const &
 	}
 	else if (state_block != nullptr && is_send (transaction_a, *state_block))
 	{
-		return state_block->hashables.link;
+		return state_block->hashables.link.as_account ();
 	}
 	static nano::account result (0);
 	return result;
@@ -904,7 +904,7 @@ nano::block_hash nano::ledger::block_source (nano::transaction const & transacti
 	nano::state_block const * state_block (dynamic_cast<nano::state_block const *> (&block_a));
 	if (state_block != nullptr && !is_send (transaction_a, *state_block))
 	{
-		result = state_block->hashables.link;
+		result = state_block->hashables.link.as_block_hash ();
 	}
 	return result;
 }
@@ -1086,7 +1086,7 @@ public:
 	void state_block (nano::state_block const & block_a) override
 	{
 		result[0] = block_a.hashables.previous;
-		result[1] = block_a.hashables.link;
+		result[1] = block_a.hashables.link.as_block_hash ();
 		// ledger.is_send will check the sideband first, if block_a has a loaded sideband the check that previous block exists can be skipped
 		if (ledger.is_epoch_link (block_a.hashables.link) || ((block_a.has_sideband () || ledger.store.block_exists (transaction, block_a.hashables.previous)) && ledger.is_send (transaction, block_a)))
 		{
@@ -1148,7 +1148,7 @@ std::shared_ptr<nano::block> nano::ledger::successor (nano::transaction const &
 	if (root_a.previous ().is_zero ())
 	{
 		nano::account_info info;
-		if (!store.account_get (transaction_a, root_a.root (), info))
+		if (!store.account_get (transaction_a, root_a.root ().as_account (), info))
 		{
 			successor = info.open_block;
 		}
@@ -1179,12 +1179,12 @@ std::shared_ptr<nano::block> nano::ledger::forked_block (nano::transaction const
 {
 	debug_assert (!store.block_exists (transaction_a, block_a.hash ()));
 	auto root (block_a.root ());
-	debug_assert (store.block_exists (transaction_a, root) || store.account_exists (transaction_a, root));
-	auto result (store.block_get (transaction_a, store.block_successor (transaction_a, root)));
+	debug_assert (store.block_exists (transaction_a, root.as_block_hash ()) || store.account_exists (transaction_a, root.as_account ()));
+	auto result (store.block_get (transaction_a, store.block_successor (transaction_a, root.as_block_hash ())));
 	if (result == nullptr)
 	{
 		nano::account_info info;
-		auto error (store.account_get (transaction_a, root, info));
+		auto error (store.account_get (transaction_a, root.as_account (), info));
 		(void)error;
 		debug_assert (!error);
 		result = store.block_get (transaction_a, info.open_block);