diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp
index 5801a08f..3154b0d8 100644
--- a/nano/core_test/active_transactions.cpp
+++ b/nano/core_test/active_transactions.cpp
@@ -1021,12 +1021,12 @@ TEST (active_transactions, activate_account_chain)
 	nano::state_block_builder builder;
 	auto send = builder.make_block ()
 				.account (nano::dev_genesis_key.pub)
-				.previous (nano::genesis_hash)
+				.previous (nano::dev::genesis->hash ())
 				.representative (nano::dev_genesis_key.pub)
 				.link (nano::dev_genesis_key.pub)
 				.balance (nano::genesis_amount - 1)
 				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				.work (*system.work.generate (nano::genesis_hash))
+				.work (*system.work.generate (nano::dev::genesis->hash ()))
 				.build ();
 	auto send2 = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
@@ -1121,12 +1121,12 @@ TEST (active_transactions, activate_inactive)
 	nano::state_block_builder builder;
 	auto send = builder.make_block ()
 				.account (nano::dev_genesis_key.pub)
-				.previous (nano::genesis_hash)
+				.previous (nano::dev::genesis->hash ())
 				.representative (nano::dev_genesis_key.pub)
 				.link (key.pub)
 				.balance (nano::genesis_amount - 1)
 				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				.work (*system.work.generate (nano::genesis_hash))
+				.work (*system.work.generate (nano::dev::genesis->hash ()))
 				.build_shared ();
 	auto send2 = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
@@ -1182,12 +1182,12 @@ TEST (active_transactions, pessimistic_elections)
 	nano::state_block_builder builder;
 	auto send = builder.make_block ()
 				.account (nano::dev_genesis_key.pub)
-				.previous (nano::genesis_hash)
+				.previous (nano::dev::genesis->hash ())
 				.representative (nano::dev_genesis_key.pub)
 				.link (nano::dev_genesis_key.pub)
 				.balance (nano::genesis_amount - 1)
 				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				.work (*system.work.generate (nano::genesis_hash))
+				.work (*system.work.generate (nano::dev::genesis->hash ()))
 				.build_shared ();
 
 	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
@@ -1321,12 +1321,12 @@ TEST (active_transactions, list_active)
 	nano::state_block_builder builder;
 	auto send = builder.make_block ()
 				.account (nano::dev_genesis_key.pub)
-				.previous (nano::genesis_hash)
+				.previous (nano::dev::genesis->hash ())
 				.representative (nano::dev_genesis_key.pub)
 				.link (nano::dev_genesis_key.pub)
 				.balance (nano::genesis_amount - 1)
 				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				.work (*system.work.generate (nano::genesis_hash))
+				.work (*system.work.generate (nano::dev::genesis->hash ()))
 				.build_shared ();
 
 	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
@@ -1376,12 +1376,12 @@ TEST (active_transactions, vacancy)
 	nano::state_block_builder builder;
 	auto send = builder.make_block ()
 				.account (nano::dev_genesis_key.pub)
-				.previous (nano::genesis_hash)
+				.previous (nano::dev::genesis->hash ())
 				.representative (nano::dev_genesis_key.pub)
 				.link (nano::dev_genesis_key.pub)
 				.balance (nano::genesis_amount - nano::Gxrb_ratio)
 				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				.work (*system.work.generate (nano::genesis_hash))
+				.work (*system.work.generate (nano::dev::genesis->hash ()))
 				.build_shared ();
 	std::atomic<bool> updated = false;
 	node.active.vacancy_update = [&updated] () { updated = true; };
@@ -1414,12 +1414,12 @@ TEST (active_transactions, fifo)
 	// Construct two pending entries that can be received simultaneously
 	auto send0 = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .link (key0.pub)
 				 .balance (nano::genesis_amount - 1)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*system.work.generate (nano::genesis_hash))
+				 .work (*system.work.generate (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.process (*send0).code);
 	nano::blocks_confirm (node, { send0 }, true);
diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp
index 1cd1062c..995b8dad 100644
--- a/nano/core_test/block_store.cpp
+++ b/nano/core_test/block_store.cpp
@@ -692,7 +692,7 @@ TEST (mdb_block_store, supported_version_upgrades)
 		store.confirmation_height.del (transaction, nano::genesis_account);
 		ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "accounts_v1", MDB_CREATE, &store.accounts_v1_handle));
 		ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle));
-		modify_account_info_to_v14 (store, transaction, nano::genesis_account, 1, nano::genesis_hash);
+		modify_account_info_to_v14 (store, transaction, nano::genesis_account, 1, nano::dev::genesis->hash ());
 		write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::genesis ().open);
 	}
 
@@ -1700,7 +1700,7 @@ TEST (mdb_block_store, upgrade_v18_v19)
 	nano::keypair key1;
 	nano::work_pool pool (std::numeric_limits<unsigned>::max ());
 	nano::network_params network_params;
-	nano::send_block send (nano::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash));
+	nano::send_block send (nano::dev::genesis->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
 	nano::receive_block receive (send.hash (), send.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send.hash ()));
 	nano::change_block change (receive.hash (), 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (receive.hash ()));
 	nano::state_block state_epoch (nano::dev_genesis_key.pub, change.hash (), 0, nano::genesis_amount, network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (change.hash ()));
@@ -1760,7 +1760,7 @@ TEST (mdb_block_store, upgrade_v18_v19)
 	ASSERT_TRUE (store.block.get (transaction, send.hash ()));
 	ASSERT_TRUE (store.block.get (transaction, receive.hash ()));
 	ASSERT_TRUE (store.block.get (transaction, change.hash ()));
-	ASSERT_TRUE (store.block.get (transaction, nano::genesis_hash));
+	ASSERT_TRUE (store.block.get (transaction, nano::dev::genesis->hash ()));
 	auto state_epoch_disk (store.block.get (transaction, state_epoch.hash ()));
 	ASSERT_NE (nullptr, state_epoch_disk);
 	ASSERT_EQ (nano::epoch::epoch_1, state_epoch_disk->sideband ().details.epoch);
diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp
index 966fe7c1..f42df2da 100644
--- a/nano/core_test/confirmation_height.cpp
+++ b/nano/core_test/confirmation_height.cpp
@@ -48,7 +48,7 @@ TEST (confirmation_height, single)
 		auto transaction = node->store.tx_begin_read ();
 		ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
 		ASSERT_EQ (1, confirmation_height_info.height);
-		ASSERT_EQ (nano::genesis_hash, confirmation_height_info.frontier);
+		ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier);
 
 		node->process_active (send1);
 		node->block_processor.flush ();
@@ -134,7 +134,7 @@ TEST (confirmation_height, multiple_accounts)
 			nano::confirmation_height_info confirmation_height_info;
 			ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
 			ASSERT_EQ (1, confirmation_height_info.height);
-			ASSERT_EQ (nano::genesis_hash, confirmation_height_info.frontier);
+			ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier);
 			ASSERT_TRUE (node->store.confirmation_height.get (transaction, key1.pub, confirmation_height_info));
 			ASSERT_EQ (0, confirmation_height_info.height);
 			ASSERT_EQ (nano::block_hash (0), confirmation_height_info.frontier);
@@ -343,7 +343,7 @@ TEST (confirmation_height, gap_live)
 			nano::confirmation_height_info confirmation_height_info;
 			ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
 			ASSERT_EQ (1, confirmation_height_info.height);
-			ASSERT_EQ (nano::genesis_hash, confirmation_height_info.frontier);
+			ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier);
 		}
 
 		// Vote and confirm all existing blocks
@@ -806,7 +806,7 @@ TEST (confirmation_heightDeathTest, modified_chain)
 		nano::write_database_queue write_database_queue (false);
 		nano::work_pool pool (std::numeric_limits<unsigned>::max ());
 		nano::keypair key1;
-		auto send = std::make_shared<nano::send_block> (nano::genesis_hash, key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash));
+		auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
 		{
 			auto transaction (store->tx_begin_write ());
 			store->initialize (transaction, ledger.cache);
@@ -832,7 +832,7 @@ TEST (confirmation_heightDeathTest, modified_chain)
 		}
 
 		ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *send).code);
-		store->confirmation_height.put (store->tx_begin_write (), nano::genesis_account, { 1, nano::genesis_hash });
+		store->confirmation_height.put (store->tx_begin_write (), nano::genesis_account, { 1, nano::dev::genesis->hash () });
 
 		nano::confirmation_height_unbounded unbounded_processor (
 		ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; });
@@ -877,7 +877,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed)
 		nano::write_database_queue write_database_queue (false);
 		nano::work_pool pool (std::numeric_limits<unsigned>::max ());
 		nano::keypair key1;
-		auto send = std::make_shared<nano::send_block> (nano::genesis_hash, key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash));
+		auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
 		auto open = std::make_shared<nano::state_block> (key1.pub, 0, 0, nano::Gxrb_ratio, send->hash (), key1.prv, key1.pub, *pool.generate (key1.pub));
 		{
 			auto transaction (store->tx_begin_write ());
@@ -906,7 +906,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed)
 
 		// Reset conditions and test with the bounded processor
 		ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *open).code);
-		store->confirmation_height.put (store->tx_begin_write (), nano::genesis_account, { 1, nano::genesis_hash });
+		store->confirmation_height.put (store->tx_begin_write (), nano::genesis_account, { 1, nano::dev::genesis->hash () });
 
 		nano::confirmation_height_bounded bounded_processor (
 		ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; });
@@ -1344,7 +1344,7 @@ TEST (confirmation_height, election_winner_details_clearing_node_process_confirm
 	nano::system system (1);
 	auto node = system.nodes.front ();
 
-	auto send = std::make_shared<nano::send_block> (nano::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash));
+	auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()));
 	// Add to election_winner_details. Use an unrealistic iteration so that it should fall into the else case and do a cleanup
 	node->active.add_election_winner_details (send->hash (), nullptr);
 	nano::election_status election;
@@ -1422,7 +1422,7 @@ TEST (confirmation_height, pruned_source)
 	nano::write_database_queue write_database_queue (false);
 	nano::work_pool pool (std::numeric_limits<unsigned>::max ());
 	nano::keypair key1, key2;
-	auto send1 = std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 100, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash));
+	auto send1 = std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 100, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
 	auto open1 = std::make_shared<nano::state_block> (key1.pub, 0, key1.pub, 100, send1->hash (), key1.prv, key1.pub, *pool.generate (key1.pub));
 	auto send2 = std::make_shared<nano::state_block> (key1.pub, open1->hash (), key1.pub, 50, key2.pub, key1.prv, key1.pub, *pool.generate (open1->hash ()));
 	auto send3 = std::make_shared<nano::state_block> (key1.pub, send2->hash (), key1.pub, 25, key2.pub, key1.prv, key1.pub, *pool.generate (send2->hash ()));
diff --git a/nano/core_test/confirmation_solicitor.cpp b/nano/core_test/confirmation_solicitor.cpp
index b32ee2ea..13a297c8 100644
--- a/nano/core_test/confirmation_solicitor.cpp
+++ b/nano/core_test/confirmation_solicitor.cpp
@@ -28,7 +28,7 @@ TEST (confirmation_solicitor, batches)
 	ASSERT_EQ (channel1, representatives.front ().channel);
 	ASSERT_EQ (nano::dev_genesis_key.pub, representatives.front ().account);
 	ASSERT_TIMELY (3s, node2.network.size () == 1);
-	auto send (std::make_shared<nano::send_block> (nano::genesis_hash, nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash)));
+	auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
 	send->sideband_set ({});
 	{
 		nano::lock_guard<nano::mutex> guard (node2.active.mutex);
@@ -72,7 +72,7 @@ TEST (confirmation_solicitor, different_hash)
 	ASSERT_EQ (channel1, representatives.front ().channel);
 	ASSERT_EQ (nano::dev_genesis_key.pub, representatives.front ().account);
 	ASSERT_TIMELY (3s, node2.network.size () == 1);
-	auto send (std::make_shared<nano::send_block> (nano::genesis_hash, nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash)));
+	auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
 	send->sideband_set ({});
 	auto election (std::make_shared<nano::election> (node2, send, nullptr, nullptr, nano::election_behavior::normal));
 	// Add a vote for something else, not the winner
@@ -108,7 +108,7 @@ TEST (confirmation_solicitor, bypass_max_requests_cap)
 	ASSERT_EQ (max_representatives + 1, representatives.size ());
 	solicitor.prepare (representatives);
 	ASSERT_TIMELY (3s, node2.network.size () == 1);
-	auto send (std::make_shared<nano::send_block> (nano::genesis_hash, nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash)));
+	auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
 	send->sideband_set ({});
 	auto election (std::make_shared<nano::election> (node2, send, nullptr, nullptr, nano::election_behavior::normal));
 	// Add a vote for something else, not the winner
diff --git a/nano/core_test/election.cpp b/nano/core_test/election.cpp
index 941fc618..4afcfb0e 100644
--- a/nano/core_test/election.cpp
+++ b/nano/core_test/election.cpp
@@ -29,7 +29,7 @@ TEST (election, quorum_minimum_flip_success)
 	nano::block_builder builder;
 	auto send1 = builder.state ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (node1.online_reps.delta ())
 				 .link (key1.pub)
@@ -40,7 +40,7 @@ TEST (election, quorum_minimum_flip_success)
 	nano::keypair key2;
 	auto send2 = builder.state ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (node1.online_reps.delta ())
 				 .link (key2.pub)
@@ -75,7 +75,7 @@ TEST (election, quorum_minimum_flip_fail)
 	nano::block_builder builder;
 	auto send1 = builder.state ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (node1.online_reps.delta () - 1)
 				 .link (key1.pub)
@@ -86,7 +86,7 @@ TEST (election, quorum_minimum_flip_fail)
 	nano::keypair key2;
 	auto send2 = builder.state ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (node1.online_reps.delta () - 1)
 				 .link (key2.pub)
@@ -121,7 +121,7 @@ TEST (election, quorum_minimum_confirm_success)
 	nano::block_builder builder;
 	auto send1 = builder.state ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (node1.online_reps.delta ())
 				 .link (key1.pub)
@@ -154,7 +154,7 @@ TEST (election, quorum_minimum_confirm_fail)
 	nano::block_builder builder;
 	auto send1 = builder.state ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (node1.online_reps.delta () - 1)
 				 .link (key1.pub)
@@ -190,7 +190,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks)
 	nano::block_builder builder;
 	auto send1 = builder.state ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (amount)
 				 .link (key1.pub)
diff --git a/nano/core_test/election_scheduler.cpp b/nano/core_test/election_scheduler.cpp
index 12cb23de..368ee24f 100644
--- a/nano/core_test/election_scheduler.cpp
+++ b/nano/core_test/election_scheduler.cpp
@@ -19,12 +19,12 @@ TEST (election_scheduler, activate_one_timely)
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
 				 .link (nano::dev_genesis_key.pub)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*system.work.generate (nano::genesis_hash))
+				 .work (*system.work.generate (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1);
 	system.nodes[0]->scheduler.activate (nano::dev_genesis_key.pub, system.nodes[0]->store.tx_begin_read ());
@@ -37,12 +37,12 @@ TEST (election_scheduler, activate_one_flush)
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
 				 .link (nano::dev_genesis_key.pub)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*system.work.generate (nano::genesis_hash))
+				 .work (*system.work.generate (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1);
 	system.nodes[0]->scheduler.activate (nano::dev_genesis_key.pub, system.nodes[0]->store.tx_begin_read ());
@@ -62,12 +62,12 @@ TEST (election_scheduler, no_vacancy)
 	// Activating accounts depends on confirmed dependencies. First, prepare 2 accounts
 	auto send = builder.make_block ()
 				.account (nano::dev_genesis_key.pub)
-				.previous (nano::genesis_hash)
+				.previous (nano::dev::genesis->hash ())
 				.representative (nano::dev_genesis_key.pub)
 				.link (key.pub)
 				.balance (nano::genesis_amount - nano::Gxrb_ratio)
 				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				.work (*system.work.generate (nano::genesis_hash))
+				.work (*system.work.generate (nano::dev::genesis->hash ()))
 				.build_shared ();
 	auto receive = builder.make_block ()
 				   .account (key.pub)
@@ -135,12 +135,12 @@ TEST (election_scheduler, flush_vacancy)
 
 	auto send = builder.make_block ()
 				.account (nano::dev_genesis_key.pub)
-				.previous (nano::genesis_hash)
+				.previous (nano::dev::genesis->hash ())
 				.representative (nano::dev_genesis_key.pub)
 				.link (key.pub)
 				.balance (nano::genesis_amount - nano::Gxrb_ratio)
 				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				.work (*system.work.generate (nano::genesis_hash))
+				.work (*system.work.generate (nano::dev::genesis->hash ()))
 				.build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
 	node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ());
diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp
index 8f0aae15..bec09a76 100644
--- a/nano/core_test/ledger.cpp
+++ b/nano/core_test/ledger.cpp
@@ -742,7 +742,7 @@ TEST (votes, add_existing)
 	nano::block_builder builder;
 	std::shared_ptr<nano::block> send1 = builder.state ()
 										 .account (nano::dev_genesis_key.pub)
-										 .previous (nano::genesis_hash)
+										 .previous (nano::dev::genesis->hash ())
 										 .representative (nano::dev_genesis_key.pub) // No representative, blocks can't confirm
 										 .balance (nano::genesis_amount / 2 - nano::Gxrb_ratio)
 										 .link (key1.pub)
@@ -762,7 +762,7 @@ TEST (votes, add_existing)
 	nano::keypair key2;
 	std::shared_ptr<nano::block> send2 = builder.state ()
 										 .account (nano::dev_genesis_key.pub)
-										 .previous (nano::genesis_hash)
+										 .previous (nano::dev::genesis->hash ())
 										 .representative (nano::dev_genesis_key.pub) // No representative, blocks can't confirm
 										 .balance (nano::genesis_amount / 2 - nano::Gxrb_ratio)
 										 .link (key2.pub)
@@ -2563,12 +2563,12 @@ TEST (ledger, epoch_open_pending)
 	// New block to process epoch open
 	auto send1 = builder.state ()
 				 .account (nano::genesis_account)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::genesis_account)
 				 .balance (nano::genesis_amount - 100)
 				 .link (key1.pub)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*pool.generate (nano::genesis_hash))
+				 .work (*pool.generate (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	node1.block_processor.add (send1);
 	node1.block_processor.flush ();
@@ -3000,7 +3000,7 @@ TEST (ledger, work_validation)
 	std::error_code ec;
 
 	auto send = *builder.send ()
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .destination (gen.pub)
 				 .balance (nano::genesis_amount - 1)
 				 .sign (gen.prv, gen.pub)
@@ -3735,12 +3735,12 @@ TEST (ledger, migrate_lmdb_to_rocksdb)
 
 	auto send = nano::state_block_builder ()
 				.account (nano::dev_genesis_key.pub)
-				.previous (nano::genesis_hash)
+				.previous (nano::dev::genesis->hash ())
 				.representative (0)
 				.link (nano::account (10))
 				.balance (nano::genesis_amount - 100)
 				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				.work (*pool.generate (nano::genesis_hash))
+				.work (*pool.generate (nano::dev::genesis->hash ()))
 				.build_shared ();
 
 	nano::endpoint_key endpoint_key (address.to_bytes (), port);
@@ -3760,7 +3760,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb)
 
 		store.pending.put (transaction, nano::pending_key (nano::genesis_account, send->hash ()), nano::pending_info (nano::genesis_account, 100, nano::epoch::epoch_0));
 		store.pruned.put (transaction, send->hash ());
-		store.unchecked.put (transaction, nano::genesis_hash, send);
+		store.unchecked.put (transaction, nano::dev::genesis->hash (), send);
 		store.version.put (transaction, version);
 		send->sideband_set ({});
 		store.block.put (transaction, send->hash (), *send);
@@ -3797,7 +3797,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb)
 	ASSERT_TRUE (rocksdb_store.final_vote.get (rocksdb_transaction, nano::root (send->previous ())).size () == 1);
 	ASSERT_EQ (rocksdb_store.final_vote.get (rocksdb_transaction, nano::root (send->previous ()))[0], nano::block_hash (2));
 
-	auto unchecked_infos = rocksdb_store.unchecked.get (rocksdb_transaction, nano::genesis_hash);
+	auto unchecked_infos = rocksdb_store.unchecked.get (rocksdb_transaction, nano::dev::genesis->hash ());
 	ASSERT_EQ (unchecked_infos.size (), 1);
 	ASSERT_EQ (unchecked_infos.front ().account, nano::genesis_account);
 	ASSERT_EQ (*unchecked_infos.front ().block, *send);
diff --git a/nano/core_test/ledger_walker.cpp b/nano/core_test/ledger_walker.cpp
index 20fb7778..d76e8b67 100644
--- a/nano/core_test/ledger_walker.cpp
+++ b/nano/core_test/ledger_walker.cpp
@@ -19,19 +19,19 @@ TEST (ledger_walker, genesis_block)
 	nano::ledger_walker ledger_walker{ node->ledger };
 
 	std::size_t walked_blocks_count = 0;
-	ledger_walker.walk_backward (nano::genesis_hash,
+	ledger_walker.walk_backward (nano::dev::genesis->hash (),
 	[&] (const auto & block) {
 		++walked_blocks_count;
-		EXPECT_EQ (block->hash (), nano::genesis_hash);
+		EXPECT_EQ (block->hash (), nano::dev::genesis->hash ());
 	});
 
 	EXPECT_EQ (walked_blocks_count, 1);
 
 	walked_blocks_count = 0;
-	ledger_walker.walk (nano::genesis_hash,
+	ledger_walker.walk (nano::dev::genesis->hash (),
 	[&] (const auto & block) {
 		++walked_blocks_count;
-		EXPECT_EQ (block->hash (), nano::genesis_hash);
+		EXPECT_EQ (block->hash (), nano::dev::genesis->hash ());
 	});
 
 	EXPECT_EQ (walked_blocks_count, 1);
diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp
index e6516e50..615634a5 100644
--- a/nano/core_test/node.cpp
+++ b/nano/core_test/node.cpp
@@ -1718,11 +1718,11 @@ TEST (node, broadcast_elected)
 			auto transaction1 (node1->store.tx_begin_write ());
 			auto transaction2 (node2->store.tx_begin_write ());
 			auto fund_big = *builder.send ()
-							 .previous (nano::genesis_hash)
+							 .previous (nano::dev::genesis->hash ())
 							 .destination (rep_big.pub)
 							 .balance (nano::Gxrb_ratio * 5)
 							 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-							 .work (*system.work.generate (nano::genesis_hash))
+							 .work (*system.work.generate (nano::dev::genesis->hash ()))
 							 .build ();
 			auto open_big = *builder.open ()
 							 .source (fund_big.hash ())
@@ -1836,11 +1836,11 @@ TEST (node, rep_self_vote)
 	nano::keypair rep_big;
 	nano::block_builder builder;
 	auto fund_big = *builder.send ()
-					 .previous (nano::genesis_hash)
+					 .previous (nano::dev::genesis->hash ())
 					 .destination (rep_big.pub)
 					 .balance (nano::uint128_t{ "0xb0000000000000000000000000000000" })
 					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-					 .work (*system.work.generate (nano::genesis_hash))
+					 .work (*system.work.generate (nano::dev::genesis->hash ()))
 					 .build ();
 	auto open_big = *builder.open ()
 					 .source (fund_big.hash ())
@@ -1924,11 +1924,11 @@ TEST (node, bootstrap_bulk_push)
 	nano::keypair key0;
 	// node0 knows about send0 but node1 doesn't.
 	auto send0 = nano::send_block_builder ()
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .destination (key0.pub)
 				 .balance (500)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*node0->work_generate_blocking (nano::genesis_hash))
+				 .work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node0->process (*send0).code);
 
@@ -1962,11 +1962,11 @@ TEST (node, bootstrap_fork_open)
 	nano::keypair key0;
 	nano::block_builder builder;
 	auto send0 = *builder.send ()
-				  .previous (nano::genesis_hash)
+				  .previous (nano::dev::genesis->hash ())
 				  .destination (key0.pub)
 				  .balance (nano::genesis_amount - 500)
 				  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				  .work (*system.work.generate (nano::genesis_hash))
+				  .work (*system.work.generate (nano::dev::genesis->hash ()))
 				  .build ();
 	auto open0 = *builder.open ()
 				  .source (send0.hash ())
@@ -2018,11 +2018,11 @@ TEST (node, bootstrap_confirm_frontiers)
 	nano::keypair key0;
 	// node0 knows about send0 but node1 doesn't.
 	auto send0 = nano::send_block_builder ()
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .destination (key0.pub)
 				 .balance (nano::genesis_amount - 500)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*node0->work_generate_blocking (nano::genesis_hash))
+				 .work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node0->process (*send0).code);
 
@@ -2496,7 +2496,7 @@ TEST (node, online_reps_rep_crawler)
 	nano::node_flags flags;
 	flags.disable_rep_crawler = true;
 	auto & node1 = *system.add_node (flags);
-	auto vote = std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector<nano::block_hash>{ nano::genesis_hash });
+	auto vote = std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector<nano::block_hash>{ nano::dev::genesis->hash () });
 	ASSERT_EQ (0, node1.online_reps.online ());
 	// Without rep crawler
 	node1.vote_processor.vote_blocking (vote, std::make_shared<nano::transport::channel_loopback> (node1));
@@ -2504,7 +2504,7 @@ TEST (node, online_reps_rep_crawler)
 	// After inserting to rep crawler
 	{
 		nano::lock_guard<nano::mutex> guard (node1.rep_crawler.probable_reps_mutex);
-		node1.rep_crawler.active.insert (nano::genesis_hash);
+		node1.rep_crawler.active.insert (nano::dev::genesis->hash ());
 	}
 	node1.vote_processor.vote_blocking (vote, std::make_shared<nano::transport::channel_loopback> (node1));
 	ASSERT_EQ (nano::genesis_amount, node1.online_reps.online ());
@@ -2957,12 +2957,12 @@ TEST (node, vote_by_hash_bundle)
 	std::vector<std::shared_ptr<nano::state_block>> blocks;
 	auto block = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (nano::genesis_amount - 1)
 				 .link (nano::dev_genesis_key.pub)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*system.work.generate (nano::genesis_hash))
+				 .work (*system.work.generate (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	blocks.push_back (block);
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ()).code);
@@ -3974,12 +3974,12 @@ TEST (node, rollback_vote_self)
 	auto weight = node.online_reps.delta ();
 	auto send1 = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .link (key.pub)
 				 .balance (nano::genesis_amount - weight)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*system.work.generate (nano::genesis_hash))
+				 .work (*system.work.generate (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	auto open = builder.make_block ()
 				.account (key.pub)
@@ -4063,12 +4063,12 @@ TEST (node, rollback_gap_source)
 	nano::keypair key;
 	auto send1 = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .link (key.pub)
 				 .balance (nano::genesis_amount - 1)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*system.work.generate (nano::genesis_hash))
+				 .work (*system.work.generate (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	auto fork = builder.make_block ()
 				.account (key.pub)
@@ -4160,12 +4160,12 @@ TEST (node, dependency_graph)
 	// Send to key1
 	auto gen_send1 = builder.make_block ()
 					 .account (nano::dev_genesis_key.pub)
-					 .previous (nano::genesis_hash)
+					 .previous (nano::dev::genesis->hash ())
 					 .representative (nano::dev_genesis_key.pub)
 					 .link (key1.pub)
 					 .balance (nano::genesis_amount - 1)
 					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-					 .work (*system.work.generate (nano::genesis_hash))
+					 .work (*system.work.generate (nano::dev::genesis->hash ()))
 					 .build_shared ();
 	// Receive from genesis
 	auto key1_open = builder.make_block ()
@@ -4362,12 +4362,12 @@ TEST (node, dependency_graph_frontier)
 	// Send to key1
 	auto gen_send1 = builder.make_block ()
 					 .account (nano::dev_genesis_key.pub)
-					 .previous (nano::genesis_hash)
+					 .previous (nano::dev::genesis->hash ())
 					 .representative (nano::dev_genesis_key.pub)
 					 .link (key1.pub)
 					 .balance (nano::genesis_amount - 1)
 					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-					 .work (*system.work.generate (nano::genesis_hash))
+					 .work (*system.work.generate (nano::dev::genesis->hash ()))
 					 .build_shared ();
 	// Receive from genesis
 	auto key1_open = builder.make_block ()
@@ -4525,12 +4525,12 @@ TEST (node, deferred_dependent_elections)
 	nano::keypair key;
 	auto send1 = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .link (key.pub)
 				 .balance (nano::genesis_amount - 1)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*system.work.generate (nano::genesis_hash))
+				 .work (*system.work.generate (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	auto open = builder.make_block ()
 				.account (key.pub)
@@ -4678,10 +4678,10 @@ TEST (rep_crawler, local)
 	flags.disable_rep_crawler = true;
 	auto & node = *system.add_node (flags);
 	auto loopback = std::make_shared<nano::transport::channel_loopback> (node);
-	auto vote = std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, std::vector{ nano::genesis_hash });
+	auto vote = std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, std::vector{ nano::dev::genesis->hash () });
 	{
 		nano::lock_guard<nano::mutex> guard (node.rep_crawler.probable_reps_mutex);
-		node.rep_crawler.active.insert (nano::genesis_hash);
+		node.rep_crawler.active.insert (nano::dev::genesis->hash ());
 		node.rep_crawler.responses.emplace_back (loopback, vote);
 	}
 	node.rep_crawler.validate ();
diff --git a/nano/core_test/request_aggregator.cpp b/nano/core_test/request_aggregator.cpp
index f60dd14c..375003f4 100644
--- a/nano/core_test/request_aggregator.cpp
+++ b/nano/core_test/request_aggregator.cpp
@@ -375,12 +375,12 @@ TEST (request_aggregator, cannot_vote)
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (nano::genesis_amount - 1)
 				 .link (nano::dev_genesis_key.pub)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*system.work.generate (nano::genesis_hash))
+				 .work (*system.work.generate (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	auto send2 = builder.make_block ()
 				 .from (*send1)
diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp
index 4b40c740..4f573769 100644
--- a/nano/core_test/vote_processor.cpp
+++ b/nano/core_test/vote_processor.cpp
@@ -195,11 +195,11 @@ TEST (vote_processor, no_broadcast_local)
 	std::shared_ptr<nano::block> send = builder.state ()
 										.account (nano::dev_genesis_key.pub)
 										.representative (nano::dev_genesis_key.pub)
-										.previous (nano::genesis_hash)
+										.previous (nano::dev::genesis->hash ())
 										.balance (2 * node.config.vote_minimum.number ())
 										.link (key.pub)
 										.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-										.work (*system.work.generate (nano::genesis_hash))
+										.work (*system.work.generate (nano::dev::genesis->hash ()))
 										.build (ec);
 	ASSERT_FALSE (ec);
 	ASSERT_EQ (nano::process_result::progress, node.process_local (send).code);
diff --git a/nano/core_test/voting.cpp b/nano/core_test/voting.cpp
index 32bb33c7..c7e7eb03 100644
--- a/nano/core_test/voting.cpp
+++ b/nano/core_test/voting.cpp
@@ -112,7 +112,7 @@ TEST (vote_generator, session)
 	nano::vote_generator_session generator_session (node->active.generator);
 	boost::thread thread ([node, &generator_session] () {
 		nano::thread_role::set (nano::thread_role::name::request_loop);
-		generator_session.add (nano::genesis_account, nano::genesis_hash);
+		generator_session.add (nano::genesis_account, nano::dev::genesis->hash ());
 		ASSERT_EQ (0, node->stats.count (nano::stat::type::vote, nano::stat::detail::vote_indeterminate));
 		generator_session.flush ();
 	});
@@ -166,33 +166,33 @@ TEST (vote_spacing, vote_generator)
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
 				 .link (nano::dev_genesis_key.pub)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*system.work.generate (nano::genesis_hash))
+				 .work (*system.work.generate (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	auto send2 = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (nano::genesis_amount - nano::Gxrb_ratio - 1)
 				 .link (nano::dev_genesis_key.pub)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*system.work.generate (nano::genesis_hash))
+				 .work (*system.work.generate (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
 	ASSERT_EQ (0, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));
-	node.active.generator.add (nano::genesis_hash, send1->hash ());
+	node.active.generator.add (nano::dev::genesis->hash (), send1->hash ());
 	ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 1);
 	ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ()));
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
-	node.active.generator.add (nano::genesis_hash, send2->hash ());
+	node.active.generator.add (nano::dev::genesis->hash (), send2->hash ());
 	ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing) == 1);
 	ASSERT_EQ (1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));
 	std::this_thread::sleep_for (config.network_params.voting.delay);
-	node.active.generator.add (nano::genesis_hash, send2->hash ());
+	node.active.generator.add (nano::dev::genesis->hash (), send2->hash ());
 	ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 2);
 }
 
@@ -209,31 +209,31 @@ TEST (vote_spacing, rapid)
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
 				 .link (nano::dev_genesis_key.pub)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*system.work.generate (nano::genesis_hash))
+				 .work (*system.work.generate (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	auto send2 = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (nano::genesis_amount - nano::Gxrb_ratio - 1)
 				 .link (nano::dev_genesis_key.pub)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*system.work.generate (nano::genesis_hash))
+				 .work (*system.work.generate (nano::dev::genesis->hash ()))
 				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
-	node.active.generator.add (nano::genesis_hash, send1->hash ());
+	node.active.generator.add (nano::dev::genesis->hash (), send1->hash ());
 	ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 1);
 	ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ()));
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
-	node.active.generator.add (nano::genesis_hash, send2->hash ());
+	node.active.generator.add (nano::dev::genesis->hash (), send2->hash ());
 	ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing) == 1);
 	ASSERT_TIMELY (3s, 1 == node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));
 	std::this_thread::sleep_for (config.network_params.voting.delay);
-	node.active.generator.add (nano::genesis_hash, send2->hash ());
+	node.active.generator.add (nano::dev::genesis->hash (), send2->hash ());
 	ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 2);
 }
diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp
index 2d01916e..fc295738 100644
--- a/nano/core_test/wallet.cpp
+++ b/nano/core_test/wallet.cpp
@@ -1164,12 +1164,12 @@ TEST (wallet, search_pending)
 	nano::block_builder builder;
 	auto send = builder.state ()
 				.account (nano::genesis_account)
-				.previous (nano::genesis_hash)
+				.previous (nano::dev::genesis->hash ())
 				.representative (nano::genesis_account)
 				.balance (nano::genesis_amount - node.config.receive_minimum.number ())
 				.link (nano::genesis_account)
 				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				.work (*system.work.generate (nano::genesis_hash))
+				.work (*system.work.generate (nano::dev::genesis->hash ()))
 				.build ();
 	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
 
diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp
index ff6e5b15..862d35fa 100644
--- a/nano/core_test/wallets.cpp
+++ b/nano/core_test/wallets.cpp
@@ -167,12 +167,12 @@ TEST (wallets, search_pending)
 		nano::block_builder builder;
 		auto send = builder.state ()
 					.account (nano::genesis_account)
-					.previous (nano::genesis_hash)
+					.previous (nano::dev::genesis->hash ())
 					.representative (nano::genesis_account)
 					.balance (nano::genesis_amount - node.config.receive_minimum.number ())
 					.link (nano::genesis_account)
 					.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-					.work (*system.work.generate (nano::genesis_hash))
+					.work (*system.work.generate (nano::dev::genesis->hash ()))
 					.build ();
 		ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
 
diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp
index e2f34910..9cabbd06 100644
--- a/nano/rpc_test/rpc.cpp
+++ b/nano/rpc_test/rpc.cpp
@@ -234,12 +234,12 @@ TEST (rpc, account_balance)
 
 	auto send1 = builder.make_block ()
 				 .account (nano::dev_genesis_key.pub)
-				 .previous (nano::genesis_hash)
+				 .previous (nano::dev::genesis->hash ())
 				 .representative (nano::dev_genesis_key.pub)
 				 .balance (nano::genesis_amount - 1)
 				 .link (nano::dev_genesis_key.pub)
 				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				 .work (*system.work.generate (nano::genesis_hash))
+				 .work (*system.work.generate (nano::dev::genesis->hash ()))
 				 .build ();
 
 	ASSERT_EQ (nano::process_result::progress, node->process (*send1).code);
@@ -531,7 +531,7 @@ TEST (rpc, send_epoch_2)
 	request.put ("amount", "1");
 
 	// Test that the correct error is given if there is insufficient work
-	auto insufficient = system.work_generate_limited (nano::genesis_hash, min_difficulty, target_difficulty);
+	auto insufficient = system.work_generate_limited (nano::dev::genesis->hash (), min_difficulty, target_difficulty);
 	request.put ("work", nano::to_string_hex (insufficient));
 	{
 		auto response (wait_response (system, rpc, request));
@@ -2552,7 +2552,7 @@ TEST (rpc, account_representative_set_epoch_2)
 	request.put ("representative", nano::keypair ().pub.to_account ());
 
 	// Test that the correct error is given if there is insufficient work
-	auto insufficient = system.work_generate_limited (nano::genesis_hash, min_difficulty, target_difficulty);
+	auto insufficient = system.work_generate_limited (nano::dev::genesis->hash (), min_difficulty, target_difficulty);
 	request.put ("work", nano::to_string_hex (insufficient));
 	{
 		auto response (wait_response (system, rpc, request));
@@ -3729,7 +3729,7 @@ TEST (rpc, account_info)
 		ASSERT_EQ (confirmed_representative, nano::dev_genesis_key.pub.to_account ());
 
 		auto confirmed_frontier (response.get<std::string> ("confirmed_frontier"));
-		ASSERT_EQ (nano::genesis_hash.to_string (), confirmed_frontier);
+		ASSERT_EQ (nano::dev::genesis->hash ().to_string (), confirmed_frontier);
 
 		auto confirmed_height (response.get<uint64_t> ("confirmed_height"));
 		ASSERT_EQ (1, confirmed_height);
@@ -4941,7 +4941,7 @@ TEST (rpc, block_confirm_confirmed)
 	// Check confirmation history
 	auto confirmed (node->active.list_recently_cemented ());
 	ASSERT_EQ (1, confirmed.size ());
-	ASSERT_EQ (nano::genesis_hash, confirmed.begin ()->winner->hash ());
+	ASSERT_EQ (nano::dev::genesis->hash (), confirmed.begin ()->winner->hash ());
 	// Check callback
 	ASSERT_TIMELY (10s, node->stats.count (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out) != 0);
 	// Callback result is error because callback target port isn't listening
@@ -5213,7 +5213,7 @@ TEST (rpc, wallet_history)
 	ASSERT_EQ ("receive", std::get<0> (history_l[3]));
 	ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[3]));
 	ASSERT_EQ (nano::genesis_amount.convert_to<std::string> (), std::get<2> (history_l[3]));
-	ASSERT_EQ (nano::genesis_hash.to_string (), std::get<3> (history_l[3]));
+	ASSERT_EQ (nano::dev::genesis->hash ().to_string (), std::get<3> (history_l[3]));
 	ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<4> (history_l[3]));
 }
 
@@ -5623,7 +5623,7 @@ TEST (rpc, deprecated_account_format)
 	request.put ("account", account_text);
 	auto response2 (wait_response (system, rpc, request));
 	std::string frontier (response2.get<std::string> ("frontier"));
-	ASSERT_EQ (nano::genesis_hash.to_string (), frontier);
+	ASSERT_EQ (nano::dev::genesis->hash ().to_string (), frontier);
 	boost::optional<std::string> deprecated_account_format2 (response2.get_optional<std::string> ("deprecated_account_format"));
 	ASSERT_TRUE (deprecated_account_format2.is_initialized ());
 }
@@ -5634,7 +5634,7 @@ TEST (rpc, epoch_upgrade)
 	auto node = add_ipc_enabled_node (system);
 	nano::keypair key1, key2, key3;
 	nano::keypair epoch_signer (nano::dev_genesis_key);
-	auto send1 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, nano::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - 1, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash))); // to opened account
+	auto send1 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, nano::dev::genesis->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 1, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); // to opened account
 	ASSERT_EQ (nano::process_result::progress, node->process (*send1).code);
 	auto send2 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, send1->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 2, key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ()))); // to unopened account (pending)
 	ASSERT_EQ (nano::process_result::progress, node->process (*send2).code);
@@ -5728,7 +5728,7 @@ TEST (rpc, epoch_upgrade_multithreaded)
 	auto node = add_ipc_enabled_node (system, node_config);
 	nano::keypair key1, key2, key3;
 	nano::keypair epoch_signer (nano::dev_genesis_key);
-	auto send1 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, nano::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - 1, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash))); // to opened account
+	auto send1 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, nano::dev::genesis->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 1, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); // to opened account
 	ASSERT_EQ (nano::process_result::progress, node->process (*send1).code);
 	auto send2 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, send1->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 2, key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ()))); // to unopened account (pending)
 	ASSERT_EQ (nano::process_result::progress, node->process (*send2).code);
@@ -5821,7 +5821,7 @@ TEST (rpc, account_lazy_start)
 	auto node1 = system.add_node (node_flags);
 	nano::keypair key;
 	// Generating test chain
-	auto send1 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, nano::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash)));
+	auto send1 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, nano::dev::genesis->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
 	ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
 	auto open (std::make_shared<nano::open_block> (send1->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)));
 	ASSERT_EQ (nano::process_result::progress, node1->process (*open).code);
@@ -5857,7 +5857,7 @@ TEST (rpc, receive)
 	wallet->insert_adhoc (nano::dev_genesis_key.prv);
 	nano::keypair key1;
 	wallet->insert_adhoc (key1.prv);
-	auto send1 (wallet->send_action (nano::dev_genesis_key.pub, key1.pub, node->config.receive_minimum.number (), *node->work_generate_blocking (nano::genesis_hash)));
+	auto send1 (wallet->send_action (nano::dev_genesis_key.pub, key1.pub, node->config.receive_minimum.number (), *node->work_generate_blocking (nano::dev::genesis->hash ())));
 	ASSERT_TIMELY (5s, node->balance (nano::dev_genesis_key.pub) != nano::genesis_amount);
 	ASSERT_TIMELY (10s, !node->store.account.exists (node->store.tx_begin_read (), key1.pub));
 	// Send below minimum receive amount
@@ -5898,7 +5898,7 @@ TEST (rpc, receive_unopened)
 	wallet->insert_adhoc (nano::dev_genesis_key.prv);
 	// Test receiving for unopened account
 	nano::keypair key1;
-	auto send1 (wallet->send_action (nano::dev_genesis_key.pub, key1.pub, node->config.receive_minimum.number () - 1, *node->work_generate_blocking (nano::genesis_hash)));
+	auto send1 (wallet->send_action (nano::dev_genesis_key.pub, key1.pub, node->config.receive_minimum.number () - 1, *node->work_generate_blocking (nano::dev::genesis->hash ())));
 	ASSERT_TIMELY (5s, !node->balance (nano::dev_genesis_key.pub) != nano::genesis_amount);
 	ASSERT_FALSE (node->store.account.exists (node->store.tx_begin_read (), key1.pub));
 	ASSERT_TRUE (node->store.block.exists (node->store.tx_begin_read (), send1->hash ()));
@@ -5993,7 +5993,7 @@ TEST (rpc, receive_pruned)
 	wallet1->insert_adhoc (nano::dev_genesis_key.prv);
 	nano::keypair key1;
 	wallet2->insert_adhoc (key1.prv);
-	auto send1 (wallet1->send_action (nano::dev_genesis_key.pub, key1.pub, node2->config.receive_minimum.number (), *node2->work_generate_blocking (nano::genesis_hash)));
+	auto send1 (wallet1->send_action (nano::dev_genesis_key.pub, key1.pub, node2->config.receive_minimum.number (), *node2->work_generate_blocking (nano::dev::genesis->hash ())));
 	ASSERT_TIMELY (5s, node2->balance (nano::dev_genesis_key.pub) != nano::genesis_amount);
 	ASSERT_TIMELY (10s, !node2->store.account.exists (node2->store.tx_begin_read (), key1.pub));
 	// Send below minimum receive amount
diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp
index c9faaec3..4ebd64f4 100644
--- a/nano/secure/common.cpp
+++ b/nano/secure/common.cpp
@@ -79,6 +79,9 @@ char const * live_canary_public_key_data = "7CBAF192A3763DAEC9F9BAC1B2CDF665D836
 std::string const test_canary_public_key_data = nano::get_env_or_default ("NANO_TEST_CANARY_PUB", "3BAD2C554ACE05F5E528FBBCE79D51E552C55FA765CCFD89B289C4835DE5F04A"); // nano_1gxf7jcnomi7yqkkjyxwwygo5sckrohtgsgezp6u74g6ifgydw4cajwbk8bf
 }
 
+nano::ledger_constants nano::dev::constants{ nano::networks::nano_dev_network };
+std::shared_ptr<nano::block> & nano::dev::genesis = nano::dev::constants.genesis;
+
 nano::network_params::network_params () :
 	network_params (network_constants::active_network)
 {
diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp
index 383f7ae9..3648b898 100644
--- a/nano/secure/common.hpp
+++ b/nano/secure/common.hpp
@@ -396,6 +396,12 @@ public:
 	nano::epochs epochs;
 };
 
+namespace dev
+{
+	extern nano::ledger_constants constants;
+	extern std::shared_ptr<nano::block> & genesis;
+}
+
 /** Constants which depend on random values (this class should never be used globally due to CryptoPP globals potentially not being initialized) */
 class random_constants
 {
diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp
index 94f97e8f..4780ab28 100644
--- a/nano/slow_test/node.cpp
+++ b/nano/slow_test/node.cpp
@@ -483,7 +483,7 @@ TEST (node, mass_vote_by_hash)
 {
 	nano::system system (1);
 	system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
-	nano::block_hash previous (nano::genesis_hash);
+	nano::block_hash previous (nano::dev::genesis->hash ());
 	nano::keypair key;
 	std::vector<std::shared_ptr<nano::state_block>> blocks;
 	for (auto i (0); i < 10000; ++i)
@@ -979,7 +979,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
 
 	auto const num_accounts = 100000;
 
-	auto latest_genesis = nano::genesis_hash;
+	auto latest_genesis = nano::dev::genesis->hash ();
 	std::vector<nano::keypair> keys;
 	std::vector<std::shared_ptr<nano::open_block>> open_blocks;
 
@@ -1828,7 +1828,7 @@ TEST (node, wallet_create_block_confirm_conflicts)
 		auto const num_blocks = 10000;
 
 		// First open the other account
-		auto latest = nano::genesis_hash;
+		auto latest = nano::dev::genesis->hash ();
 		nano::keypair key1;
 		{
 			auto transaction = node->store.tx_begin_write ();
diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp
index 6a986d4b..a5888292 100644
--- a/nano/test_common/system.cpp
+++ b/nano/test_common/system.cpp
@@ -151,7 +151,7 @@ nano::system::~system ()
 
 void nano::system::ledger_initialization_set (std::vector<nano::keypair> const & reps, nano::amount const & reserve)
 {
-	nano::block_hash previous = nano::genesis_hash;
+	nano::block_hash previous = nano::dev::genesis->hash ();
 	auto amount = (nano::genesis_amount - reserve.number ()) / reps.size ();
 	auto balance = nano::genesis_amount;
 	for (auto const & i : reps)
diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp
index 3e972817..1f593991 100644
--- a/nano/test_common/testutil.cpp
+++ b/nano/test_common/testutil.cpp
@@ -19,7 +19,6 @@ nano::keypair const & nano::zero_key (dev_constants.zero_key);
 nano::keypair const & nano::dev_genesis_key (dev_constants.dev_genesis_key);
 nano::account const & nano::nano_dev_account (dev_constants.nano_dev_account);
 nano::account const & nano::genesis_account (dev_constants.genesis_account ());
-nano::block_hash const & nano::genesis_hash (dev_constants.genesis_hash ());
 nano::uint128_t const & nano::genesis_amount (dev_constants.genesis_amount);
 nano::account const & nano::burn_account (dev_constants.burn_account);
 
diff --git a/nano/test_common/testutil.hpp b/nano/test_common/testutil.hpp
index 74cf8bc9..bf890b28 100644
--- a/nano/test_common/testutil.hpp
+++ b/nano/test_common/testutil.hpp
@@ -55,7 +55,6 @@ class system;
 
 extern nano::keypair const & zero_key;
 extern nano::keypair const & dev_genesis_key;
-extern nano::block_hash const & genesis_hash;
 extern nano::public_key const & nano_dev_account;
 extern nano::public_key const & genesis_account;
 extern nano::public_key const & burn_account;