diff --git a/nano/core_test/core_test_main.cc b/nano/core_test/core_test_main.cc
index a650cd67..a484b84f 100644
--- a/nano/core_test/core_test_main.cc
+++ b/nano/core_test/core_test_main.cc
@@ -1,10 +1,12 @@
-
-extern void force_nano_test_network ();
-
 #include "gtest/gtest.h"
-GTEST_API_ int main(int argc, char **argv) {
-  printf("Running main() from core_test_main.cc\n");
-  force_nano_test_network ();
-  testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
\ No newline at end of file
+namespace nano
+{
+void force_nano_test_network ();
+}
+GTEST_API_ int main (int argc, char ** argv)
+{
+	printf ("Running main() from core_test_main.cc\n");
+	nano::force_nano_test_network ();
+	testing::InitGoogleTest (&argc, argv);
+	return RUN_ALL_TESTS ();
+}
diff --git a/nano/core_test/rpc.cpp b/nano/core_test/rpc.cpp
index 004ae4b6..36e1fd36 100644
--- a/nano/core_test/rpc.cpp
+++ b/nano/core_test/rpc.cpp
@@ -2672,7 +2672,7 @@ TEST (rpc, wallet_frontiers)
 
 TEST (rpc, work_validate)
 {
-	nano::network_params params;
+	nano::network_constants constants;
 	nano::system system (24000, 1);
 	nano::node_init init1;
 	auto & node1 (*system.nodes[0]);
@@ -2709,7 +2709,7 @@ TEST (rpc, work_validate)
 	ASSERT_EQ ("0", validate_text2);
 	uint64_t result_difficulty;
 	ASSERT_FALSE (nano::work_validate (hash, work1, &result_difficulty));
-	ASSERT_GE (result_difficulty, params.publish_threshold);
+	ASSERT_GE (result_difficulty, constants.publish_threshold);
 	request.put ("work", nano::to_string_hex (work1));
 	request.put ("difficulty", nano::to_string_hex (result_difficulty));
 	test_response response3 (request, rpc, system.io_ctx);
diff --git a/nano/core_test/work_pool.cpp b/nano/core_test/work_pool.cpp
index 5c1216a2..c73f9175 100644
--- a/nano/core_test/work_pool.cpp
+++ b/nano/core_test/work_pool.cpp
@@ -7,26 +7,26 @@
 
 TEST (work, one)
 {
-	nano::network_params params;
+	nano::network_constants network_constants;
 	nano::work_pool pool (std::numeric_limits<unsigned>::max ());
 	nano::change_block block (1, 1, nano::keypair ().prv, 3, 4);
 	block.block_work_set (pool.generate (block.root ()));
 	uint64_t difficulty;
 	ASSERT_FALSE (nano::work_validate (block, &difficulty));
-	ASSERT_LT (params.publish_threshold, difficulty);
+	ASSERT_LT (network_constants.publish_threshold, difficulty);
 }
 
 TEST (work, validate)
 {
-	nano::network_params params;
+	nano::network_constants network_constants;
 	nano::work_pool pool (std::numeric_limits<unsigned>::max ());
 	nano::send_block send_block (1, 1, 2, nano::keypair ().prv, 4, 6);
 	uint64_t difficulty;
 	ASSERT_TRUE (nano::work_validate (send_block, &difficulty));
-	ASSERT_LT (difficulty, params.publish_threshold);
+	ASSERT_LT (difficulty, network_constants.publish_threshold);
 	send_block.block_work_set (pool.generate (send_block.root ()));
 	ASSERT_FALSE (nano::work_validate (send_block, &difficulty));
-	ASSERT_LT (params.publish_threshold, difficulty);
+	ASSERT_LT (network_constants.publish_threshold, difficulty);
 }
 
 TEST (work, cancel)
diff --git a/nano/lib/blockbuilders.cpp b/nano/lib/blockbuilders.cpp
index f7ede8a6..34812500 100644
--- a/nano/lib/blockbuilders.cpp
+++ b/nano/lib/blockbuilders.cpp
@@ -1,6 +1,5 @@
 #include <crypto/cryptopp/osrng.h>
 #include <nano/lib/blockbuilders.hpp>
-#include <nano/secure/common.hpp>
 #include <unordered_map>
 
 namespace
diff --git a/nano/lib/config.cpp b/nano/lib/config.cpp
index 6fe40dd8..b63bf1ba 100644
--- a/nano/lib/config.cpp
+++ b/nano/lib/config.cpp
@@ -1,147 +1,9 @@
-#include <iostream>
-#include <limits>
-#include <nano/core_test/testutil.hpp>
 #include <nano/lib/config.hpp>
 
-nano::nano_networks nano::network_params::active_network = nano::nano_networks::ACTIVE_NETWORK;
-
-namespace
+namespace nano
 {
-char const * test_private_key_data = "34F0A37AAD20F4A260F0A5B3CB3D7FB50673212263E58A380BC10474BB039CE4";
-char const * test_public_key_data = "B0311EA55708D6A53C75CDBF88300259C6D018522FE3D4D0A242E431F9E8B6D0"; // xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpiij4txtdo
-char const * beta_public_key_data = "A59A47CC4F593E75AE9AD653FDA9358E2F7898D9ACC8C60E80D0495CE20FBA9F"; // xrb_3betaz86ypbygpqbookmzpnmd5jhh4efmd8arr9a3n4bdmj1zgnzad7xpmfp
-char const * live_public_key_data = "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA"; // xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3
-char const * test_genesis_data = R"%%%({
-	"type": "open",
-	"source": "B0311EA55708D6A53C75CDBF88300259C6D018522FE3D4D0A242E431F9E8B6D0",
-	"representative": "xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpiij4txtdo",
-	"account": "xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpiij4txtdo",
-	"work": "9680625b39d3363d",
-	"signature": "ECDA914373A2F0CA1296475BAEE40500A7F0A7AD72A5A80C81D7FAB7F6C802B2CC7DB50F5DD0FB25B2EF11761FA7344A158DD5A700B21BD47DE5BD0F63153A02"
-	})%%%";
-
-char const * beta_genesis_data = R"%%%({
-	"type": "open",
-	"source": "A59A47CC4F593E75AE9AD653FDA9358E2F7898D9ACC8C60E80D0495CE20FBA9F",
-	"representative": "xrb_3betaz86ypbygpqbookmzpnmd5jhh4efmd8arr9a3n4bdmj1zgnzad7xpmfp",
-	"account": "xrb_3betaz86ypbygpqbookmzpnmd5jhh4efmd8arr9a3n4bdmj1zgnzad7xpmfp",
-	"work": "000000000f0aaeeb",
-	"signature": "A726490E3325E4FA59C1C900D5B6EEBB15FE13D99F49D475B93F0AACC5635929A0614CF3892764A04D1C6732A0D716FFEB254D4154C6F544D11E6630F201450B"
-	})%%%";
-
-char const * live_genesis_data = R"%%%({
-	"type": "open",
-	"source": "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA",
-	"representative": "xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3",
-	"account": "xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3",
-	"work": "62f05417dd3fb691",
-	"signature": "9F0C933C8ADE004D808EA1985FA746A7E95BA2A38F867640F53EC8F180BDFE9E2C1268DEAD7C2664F356E37ABA362BC58E46DBA03E523A7B5A19E4B6EB12BB02"
-	})%%%";
-}
-
-nano::network_params::network_params () :
-network_params (nano::network_params::active_network)
-{
-}
-
-nano::network_params::network_params (nano::nano_networks network_a) :
-current_network (network_a), ledger (*this), voting (*this), node (*this), portmapping (*this), bootstrap (*this)
-{
-	// Local work threshold for rate-limiting publishing blocks. ~5 seconds of work.
-	uint64_t constexpr publish_test_threshold = 0xff00000000000000;
-	uint64_t constexpr publish_full_threshold = 0xffffffc000000000;
-	publish_threshold = is_test_network () ? publish_test_threshold : publish_full_threshold;
-
-	unsigned constexpr kdf_full_work = 64 * 1024;
-	unsigned constexpr kdf_test_work = 8;
-	kdf_work = is_test_network () ? kdf_test_work : kdf_full_work;
-
-	default_node_port = is_live_network () ? 7075 : 54000;
-	default_rpc_port = is_live_network () ? 7076 : 55000;
-	request_interval_ms = is_test_network () ? 10 : 16000;
-	header_magic_number = is_test_network () ? std::array<uint8_t, 2>{ { 'R', 'A' } } : is_beta_network () ? std::array<uint8_t, 2>{ { 'R', 'B' } } : std::array<uint8_t, 2>{ { 'R', 'C' } };
-}
-
-nano::ledger_constants::ledger_constants (nano::network_params & params_a) :
-ledger_constants (params_a.network ())
-{
-}
-
-nano::ledger_constants::ledger_constants (nano::nano_networks network_a) :
-zero_key ("0"),
-test_genesis_key (test_private_key_data),
-nano_test_account (test_public_key_data),
-nano_beta_account (beta_public_key_data),
-nano_live_account (live_public_key_data),
-nano_test_genesis (test_genesis_data),
-nano_beta_genesis (beta_genesis_data),
-nano_live_genesis (live_genesis_data),
-genesis_account (network_a == nano::nano_networks::nano_test_network ? nano_test_account : network_a == nano::nano_networks::nano_beta_network ? nano_beta_account : nano_live_account),
-genesis_block (network_a == nano::nano_networks::nano_test_network ? nano_test_genesis : network_a == nano::nano_networks::nano_beta_network ? nano_beta_genesis : nano_live_genesis),
-genesis_amount (std::numeric_limits<nano::uint128_t>::max ()),
-burn_account (0),
-not_an_account_m (0)
-{
-}
-
-nano::account const & nano::ledger_constants::not_an_account ()
-{
-	if (not_an_account_m.is_zero ())
-	{
-		// Randomly generating these mean no two nodes will ever have the same sentinel values which protects against some insecure algorithms
-		nano::random_pool::generate_block (not_an_account_m.bytes.data (), not_an_account_m.bytes.size ());
-	}
-	return not_an_account_m;
-}
-
-nano::node_constants::node_constants (nano::network_params & params_a)
-{
-	period = params_a.is_test_network () ? std::chrono::seconds (1) : std::chrono::seconds (60);
-	cutoff = period * 5;
-	syn_cookie_cutoff = std::chrono::seconds (5);
-	backup_interval = std::chrono::minutes (5);
-	search_pending_interval = params_a.is_test_network () ? std::chrono::seconds (1) : std::chrono::seconds (5 * 60);
-	peer_interval = search_pending_interval;
-	unchecked_cleaning_interval = std::chrono::hours (2);
-	process_confirmed_interval = params_a.is_test_network () ? std::chrono::milliseconds (50) : std::chrono::milliseconds (500);
-	max_weight_samples = params_a.is_live_network () ? 4032 : 864;
-	weight_period = 5 * 60; // 5 minutes
-}
-
-nano::voting_constants::voting_constants (nano::network_params & params_a)
-{
-	max_cache = params_a.is_test_network () ? 2 : 1000;
-	generator_delay = params_a.is_test_network () ? std::chrono::milliseconds (10) : std::chrono::milliseconds (500);
-}
-
-nano::portmapping_constants::portmapping_constants (nano::network_params & params_a)
-{
-	mapping_timeout = params_a.is_test_network () ? 53 : 3593;
-	check_timeout = params_a.is_test_network () ? 17 : 53;
-}
-
-nano::bootstrap_constants::bootstrap_constants (nano::network_params & params_a)
-{
-	lazy_max_pull_blocks = params_a.is_test_network () ? 2 : 512;
-}
-
-/** Called by gtest_main to enforce test network */
 void force_nano_test_network ()
 {
-	nano::network_params::set_active_network (nano::nano_networks::nano_test_network);
+	nano::network_constants::set_active_network (nano::nano_networks::nano_test_network);
 }
-
-/* Convenience constants for core_test which is always on the test network */
-namespace
-{
-nano::ledger_constants test_constants (nano::nano_networks::nano_test_network);
 }
-
-nano::keypair const & nano::zero_key (test_constants.zero_key);
-nano::keypair const & nano::test_genesis_key (test_constants.test_genesis_key);
-nano::account const & nano::nano_test_account (test_constants.nano_test_account);
-std::string const & nano::nano_test_genesis (test_constants.nano_test_genesis);
-nano::account const & nano::genesis_account (test_constants.genesis_account);
-std::string const & nano::genesis_block (test_constants.genesis_block);
-nano::uint128_t const & nano::genesis_amount (test_constants.genesis_amount);
-nano::account const & nano::burn_account (test_constants.burn_account);
diff --git a/nano/lib/config.hpp b/nano/lib/config.hpp
index a9a2fb5a..a870317c 100644
--- a/nano/lib/config.hpp
+++ b/nano/lib/config.hpp
@@ -5,14 +5,10 @@
 #include <chrono>
 #include <nano/lib/errors.hpp>
 #include <nano/lib/numbers.hpp>
-#include <nano/secure/common.hpp>
 #include <string>
 
 namespace nano
 {
-class ledger_constants;
-class network_params;
-
 /**
  * Network variants with different genesis blocks and network parameters
  * @warning Enum values are used in integral comparisons; do not change.
@@ -30,103 +26,38 @@ enum class nano_networks
 	rai_live_network = 2,
 };
 
-/** Genesis keys and ledger constants for network variants */
-class ledger_constants
+class network_constants
 {
 public:
-	ledger_constants (nano::network_params & params_a);
-	ledger_constants (nano::nano_networks network_a);
-	nano::keypair zero_key;
-	nano::keypair test_genesis_key;
-	nano::account nano_test_account;
-	nano::account nano_beta_account;
-	nano::account nano_live_account;
-	std::string nano_test_genesis;
-	std::string nano_beta_genesis;
-	std::string nano_live_genesis;
-	nano::account genesis_account;
-	std::string genesis_block;
-	nano::uint128_t genesis_amount;
-	nano::account const & not_an_account ();
-	nano::account burn_account;
+	network_constants () :
+	network_constants (network_constants::active_network)
+	{
+	}
 
-private:
-	nano::account not_an_account_m;
-};
+	network_constants (nano_networks network_a) :
+	current_network (network_a)
+	{
+		// Local work threshold for rate-limiting publishing blocks. ~5 seconds of work.
+		uint64_t constexpr publish_test_threshold = 0xff00000000000000;
+		uint64_t constexpr publish_full_threshold = 0xffffffc000000000;
+		publish_threshold = is_test_network () ? publish_test_threshold : publish_full_threshold;
 
-/** Node related constants whose value depends on the active network */
-class node_constants
-{
-public:
-	node_constants (nano::network_params & params_a);
-	std::chrono::seconds period;
-	std::chrono::seconds cutoff;
-	std::chrono::seconds syn_cookie_cutoff;
-	std::chrono::minutes backup_interval;
-	std::chrono::seconds search_pending_interval;
-	std::chrono::seconds peer_interval;
-	std::chrono::hours unchecked_cleaning_interval;
-	std::chrono::milliseconds process_confirmed_interval;
-
-	/** The maximum amount of samples for a 2 week period on live or 3 days on beta */
-	uint64_t max_weight_samples;
-	uint64_t weight_period;
-};
-
-/** Voting related constants whose value depends on the active network */
-class voting_constants
-{
-public:
-	voting_constants (nano::network_params & params_a);
-	size_t max_cache;
-	std::chrono::milliseconds generator_delay;
-};
-
-/** Port-mapping related constants whose value depends on the active network */
-class portmapping_constants
-{
-public:
-	portmapping_constants (nano::network_params & params_a);
-	// Timeouts are primes so they infrequently happen at the same time
-	int mapping_timeout;
-	int check_timeout;
-};
-
-/** Bootstrap related constants whose value depends on the active network */
-class bootstrap_constants
-{
-public:
-	bootstrap_constants (nano::network_params & params_a);
-	uint64_t lazy_max_pull_blocks;
-};
-
-/** Constants whose value depends on the active network */
-class network_params
-{
-public:
-	/** Populate values based on the current active network */
-	network_params ();
-
-	/** Populate values based on \p network_a */
-	network_params (nano::nano_networks network_a);
+		default_node_port = is_live_network () ? 7075 : 54000;
+		default_rpc_port = is_live_network () ? 7076 : 55000;
+		default_ipc_port = is_live_network () ? 7077 : 24077;
+		request_interval_ms = is_test_network () ? 10 : 16000;
+	}
 
 	/** The network this param object represents. This may differ from the global active network; this is needed for certain --debug... commands */
-	nano::nano_networks current_network;
-
-	std::array<uint8_t, 2> header_magic_number;
-	unsigned request_interval_ms;
+	nano_networks current_network;
 	uint64_t publish_threshold;
-	unsigned kdf_work;
 	uint16_t default_node_port;
 	uint16_t default_rpc_port;
-	ledger_constants ledger;
-	voting_constants voting;
-	node_constants node;
-	portmapping_constants portmapping;
-	bootstrap_constants bootstrap;
+	uint16_t default_ipc_port;
+	unsigned request_interval_ms;
 
 	/** Returns the network this object contains values for */
-	nano::nano_networks network ()
+	nano_networks network () const
 	{
 		return current_network;
 	}
@@ -134,9 +65,9 @@ public:
 	/**
 	 * Optionally called on startup to override the global active network.
 	 * If not called, the compile-time option will be used.
-	 * @param network The new active network
+	 * @param network_a The new active network
 	 */
-	static void set_active_network (nano::nano_networks network_a)
+	static void set_active_network (nano_networks network_a)
 	{
 		active_network = network_a;
 	}
@@ -168,20 +99,19 @@ public:
 		return err;
 	}
 
-	bool is_live_network ()
+	bool is_live_network () const
 	{
 		return current_network == nano_networks::nano_live_network;
 	}
-	bool is_beta_network ()
+	bool is_beta_network () const
 	{
 		return current_network == nano_networks::nano_beta_network;
 	}
-	bool is_test_network ()
+	bool is_test_network () const
 	{
 		return current_network == nano_networks::nano_test_network;
 	}
 
-private:
 	/** Initial value is ACTIVE_NETWORK compile flag, but can be overridden by a CLI flag */
 	static nano::nano_networks active_network;
 };
@@ -190,6 +120,7 @@ inline boost::filesystem::path get_config_path (boost::filesystem::path const &
 {
 	return data_path / "config.json";
 }
-}
 
+/** Called by gtest_main to enforce test network */
 void force_nano_test_network ();
+}
diff --git a/nano/lib/interface.cpp b/nano/lib/interface.cpp
index cf9789eb..8b080299 100644
--- a/nano/lib/interface.cpp
+++ b/nano/lib/interface.cpp
@@ -116,7 +116,7 @@ char * xrb_sign_transaction (const char * transaction, const xrb_uint256 private
 
 char * xrb_work_transaction (const char * transaction)
 {
-	static nano::network_params network_params;
+	static nano::network_constants network_constants;
 	char * result (nullptr);
 	try
 	{
@@ -128,7 +128,7 @@ char * xrb_work_transaction (const char * transaction)
 		if (block != nullptr)
 		{
 			nano::work_pool pool (boost::thread::hardware_concurrency ());
-			auto work (pool.generate (block->root (), network_params.publish_threshold));
+			auto work (pool.generate (block->root (), network_constants.publish_threshold));
 			block->block_work_set (work);
 			auto json (block->to_json ());
 			result = reinterpret_cast<char *> (malloc (json.size () + 1));
diff --git a/nano/lib/work.cpp b/nano/lib/work.cpp
index 4ba348f9..b791ebb0 100644
--- a/nano/lib/work.cpp
+++ b/nano/lib/work.cpp
@@ -7,13 +7,13 @@
 
 bool nano::work_validate (nano::block_hash const & root_a, uint64_t work_a, uint64_t * difficulty_a)
 {
-	static nano::network_params network_params;
+	static nano::network_constants network_constants;
 	auto value (nano::work_value (root_a, work_a));
 	if (difficulty_a != nullptr)
 	{
 		*difficulty_a = value;
 	}
-	return value < network_params.publish_threshold;
+	return value < network_constants.publish_threshold;
 }
 
 bool nano::work_validate (nano::block const & block_a, uint64_t * difficulty_a)
@@ -41,7 +41,7 @@ opencl (opencl_a)
 	static_assert (ATOMIC_INT_LOCK_FREE == 2, "Atomic int needed");
 	boost::thread::attributes attrs;
 	nano::thread_attributes::set (attrs);
-	auto count (network_params.is_test_network () ? 1 : std::min (max_threads_a, std::max (1u, boost::thread::hardware_concurrency ())));
+	auto count (network_constants.is_test_network () ? 1 : std::min (max_threads_a, std::max (1u, boost::thread::hardware_concurrency ())));
 	for (auto i (0); i < count; ++i)
 	{
 		auto thread (boost::thread (attrs, [this, i]() {
@@ -114,7 +114,7 @@ void nano::work_pool::loop (uint64_t thread)
 			if (ticket == ticket_l)
 			{
 				// If the ticket matches what we started with, we're the ones that found the solution
-				assert (output >= network_params.publish_threshold);
+				assert (output >= network_constants.publish_threshold);
 				assert (work_value (current_l.item, work) == output);
 				// Signal other threads to stop their work next time they check ticket
 				++ticket;
@@ -172,7 +172,7 @@ void nano::work_pool::stop ()
 
 void nano::work_pool::generate (nano::uint256_union const & hash_a, std::function<void(boost::optional<uint64_t> const &)> callback_a)
 {
-	generate (hash_a, callback_a, network_params.publish_threshold);
+	generate (hash_a, callback_a, network_constants.publish_threshold);
 }
 
 void nano::work_pool::generate (nano::uint256_union const & hash_a, std::function<void(boost::optional<uint64_t> const &)> callback_a, uint64_t difficulty_a)
@@ -199,7 +199,7 @@ void nano::work_pool::generate (nano::uint256_union const & hash_a, std::functio
 
 uint64_t nano::work_pool::generate (nano::uint256_union const & hash_a)
 {
-	return generate (hash_a, network_params.publish_threshold);
+	return generate (hash_a, network_constants.publish_threshold);
 }
 
 uint64_t nano::work_pool::generate (nano::uint256_union const & hash_a, uint64_t difficulty_a)
diff --git a/nano/lib/work.hpp b/nano/lib/work.hpp
index d31b40f6..60b37885 100644
--- a/nano/lib/work.hpp
+++ b/nano/lib/work.hpp
@@ -37,7 +37,7 @@ public:
 	void generate (nano::uint256_union const &, std::function<void(boost::optional<uint64_t> const &)>, uint64_t);
 	uint64_t generate (nano::uint256_union const &);
 	uint64_t generate (nano::uint256_union const &, uint64_t);
-	nano::network_params network_params;
+	nano::network_constants network_constants;
 	std::atomic<int> ticket;
 	bool done;
 	std::vector<boost::thread> threads;
diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp
index 430939b5..ddab168a 100644
--- a/nano/nano_node/entry.cpp
+++ b/nano/nano_node/entry.cpp
@@ -119,7 +119,7 @@ int main (int argc, char * const * argv)
 	auto network (vm.find ("network"));
 	if (network != vm.end ())
 	{
-		auto err (nano::network_params::set_active_network (network->second.as<std::string> ()));
+		auto err (nano::network_constants::set_active_network (network->second.as<std::string> ()));
 		if (err)
 		{
 			std::cerr << err.get_message () << std::endl;
@@ -305,7 +305,7 @@ int main (int argc, char * const * argv)
 		}
 		else if (vm.count ("debug_opencl"))
 		{
-			nano::network_params network_params;
+			nano::network_constants network_constants;
 			bool error (false);
 			nano::opencl_environment environment (error);
 			if (!error)
@@ -352,7 +352,7 @@ int main (int argc, char * const * argv)
 						result = -1;
 					}
 				}
-				uint64_t difficulty (network_params.publish_threshold);
+				uint64_t difficulty (network_constants.publish_threshold);
 				auto difficulty_it = vm.find ("difficulty");
 				if (difficulty_it != vm.end ())
 				{
@@ -477,7 +477,7 @@ int main (int argc, char * const * argv)
 		}
 		else if (vm.count ("debug_profile_process"))
 		{
-			nano::network_params::set_active_network (nano::nano_networks::nano_test_network);
+			nano::network_constants::set_active_network (nano::nano_networks::nano_test_network);
 			nano::network_params test_params;
 			nano::block_builder builder;
 			size_t num_accounts (100000);
@@ -589,7 +589,7 @@ int main (int argc, char * const * argv)
 		}
 		else if (vm.count ("debug_profile_votes"))
 		{
-			nano::network_params::set_active_network (nano::nano_networks::nano_test_network);
+			nano::network_constants::set_active_network (nano::nano_networks::nano_test_network);
 			nano::network_params test_params;
 			nano::block_builder builder;
 			size_t num_elections (40000);
diff --git a/nano/nano_wallet/entry.cpp b/nano/nano_wallet/entry.cpp
index 08c3f1df..d16d7452 100644
--- a/nano/nano_wallet/entry.cpp
+++ b/nano/nano_wallet/entry.cpp
@@ -332,7 +332,7 @@ int main (int argc, char * const * argv)
 		auto network (vm.find ("network"));
 		if (network != vm.end ())
 		{
-			auto err (nano::network_params::set_active_network (network->second.as<std::string> ()));
+			auto err (nano::network_constants::set_active_network (network->second.as<std::string> ()));
 			if (err)
 			{
 				std::cerr << err.get_message () << std::endl;
diff --git a/nano/node/bootstrap.cpp b/nano/node/bootstrap.cpp
index 0b6e81f3..47683e1c 100644
--- a/nano/node/bootstrap.cpp
+++ b/nano/node/bootstrap.cpp
@@ -103,7 +103,7 @@ void nano::socket::close ()
 void nano::socket::checkup (uint64_t timeout_a)
 {
 	std::weak_ptr<nano::socket> this_w (shared_from_this ());
-	node->alarm.add (std::chrono::steady_clock::now () + std::chrono::seconds (node->network_params.is_test_network () ? 1 : 10), [this_w, timeout_a]() {
+	node->alarm.add (std::chrono::steady_clock::now () + std::chrono::seconds (node->network_params.network.is_test_network () ? 1 : 10), [this_w, timeout_a]() {
 		if (auto this_l = this_w.lock ())
 		{
 			if (this_l->async_start_time != std::numeric_limits<uint64_t>::max () && this_l->async_start_time + timeout_a < static_cast<uint64_t> (std::chrono::steady_clock::now ().time_since_epoch ().count ()))
diff --git a/nano/node/common.cpp b/nano/node/common.cpp
index 7356d999..bfecc401 100644
--- a/nano/node/common.cpp
+++ b/nano/node/common.cpp
@@ -207,7 +207,7 @@ status (parse_status::success)
 
 void nano::message_parser::deserialize_buffer (uint8_t const * buffer_a, size_t size_a)
 {
-	static nano::network_params network_params;
+	static nano::network_constants network_constants;
 	status = parse_status::success;
 	auto error (false);
 	if (size_a <= max_safe_udp_message_size)
@@ -217,7 +217,7 @@ void nano::message_parser::deserialize_buffer (uint8_t const * buffer_a, size_t
 		nano::message_header header (error, stream);
 		if (!error)
 		{
-			if (network_params.is_beta_network () && header.version_using < nano::protocol_version_reasonable_min)
+			if (network_constants.is_beta_network () && header.version_using < nano::protocol_version_reasonable_min)
 			{
 				status = parse_status::outdated_version;
 			}
diff --git a/nano/node/node.cpp b/nano/node/node.cpp
index b83753dd..9e995eab 100644
--- a/nano/node/node.cpp
+++ b/nano/node/node.cpp
@@ -737,7 +737,7 @@ void nano::vote_processor::vote (std::shared_ptr<nano::vote> vote_a, std::shared
 		/* Random early delection levels
 		Always process votes for test network (process = true)
 		Stop processing with max 144 * 1024 votes */
-		if (!node.network_params.is_test_network ())
+		if (!node.network_params.network.is_test_network ())
 		{
 			// Level 0 (< 0.1%)
 			if (votes.size () < 96 * 1024)
@@ -1226,9 +1226,9 @@ startup_time (std::chrono::steady_clock::now ())
 		logger.always_log ("Node ID: ", node_id.pub.to_account ());
 	}
 
-	const uint8_t * weight_buffer = network_params.is_live_network () ? nano_bootstrap_weights_live : nano_bootstrap_weights_beta;
-	size_t weight_size = network_params.is_live_network () ? nano_bootstrap_weights_live_size : nano_bootstrap_weights_beta_size;
-	if (network_params.is_live_network () || network_params.is_beta_network ())
+	const uint8_t * weight_buffer = network_params.network.is_live_network () ? nano_bootstrap_weights_live : nano_bootstrap_weights_beta;
+	size_t weight_size = network_params.network.is_live_network () ? nano_bootstrap_weights_live_size : nano_bootstrap_weights_beta_size;
+	if (network_params.network.is_live_network () || network_params.network.is_beta_network ())
 	{
 		nano::bufferstream weight_stream ((const uint8_t *)weight_buffer, weight_size);
 		nano::uint128_union block_height;
@@ -1467,7 +1467,7 @@ void nano::gap_cache::vote (std::shared_ptr<nano::vote> vote_a)
 				{
 					auto node_l (node.shared ());
 					auto now (std::chrono::steady_clock::now ());
-					node.alarm.add (node_l->network_params.is_test_network () ? now + std::chrono::milliseconds (5) : now + std::chrono::seconds (5), [node_l, hash]() {
+					node.alarm.add (node_l->network_params.network.is_test_network () ? now + std::chrono::milliseconds (5) : now + std::chrono::seconds (5), [node_l, hash]() {
 						auto transaction (node_l->store.tx_begin_read ());
 						if (!node_l->store.block_exists (transaction, hash))
 						{
@@ -1591,7 +1591,7 @@ void nano::node::keepalive_preconfigured (std::vector<std::string> const & peers
 {
 	for (auto i (peers_a.begin ()), n (peers_a.end ()); i != n; ++i)
 	{
-		keepalive (*i, network_params.default_node_port);
+		keepalive (*i, network_params.network.default_node_port);
 	}
 }
 
@@ -2099,7 +2099,7 @@ public:
 
 void nano::node::work_generate_blocking (nano::block & block_a)
 {
-	work_generate_blocking (block_a, network_params.publish_threshold);
+	work_generate_blocking (block_a, network_params.network.publish_threshold);
 }
 
 void nano::node::work_generate_blocking (nano::block & block_a, uint64_t difficulty_a)
@@ -2109,7 +2109,7 @@ void nano::node::work_generate_blocking (nano::block & block_a, uint64_t difficu
 
 void nano::node::work_generate (nano::uint256_union const & hash_a, std::function<void(uint64_t)> callback_a)
 {
-	work_generate (hash_a, callback_a, network_params.publish_threshold);
+	work_generate (hash_a, callback_a, network_params.network.publish_threshold);
 }
 
 void nano::node::work_generate (nano::uint256_union const & hash_a, std::function<void(uint64_t)> callback_a, uint64_t difficulty_a)
@@ -2120,7 +2120,7 @@ void nano::node::work_generate (nano::uint256_union const & hash_a, std::functio
 
 uint64_t nano::node::work_generate_blocking (nano::uint256_union const & block_a)
 {
-	return work_generate_blocking (block_a, network_params.publish_threshold);
+	return work_generate_blocking (block_a, network_params.network.publish_threshold);
 }
 
 uint64_t nano::node::work_generate_blocking (nano::uint256_union const & hash_a, uint64_t difficulty_a)
@@ -2631,7 +2631,7 @@ nano::election_vote_result nano::election::vote (nano::account rep, uint64_t seq
 	auto supply (node.online_reps.online_stake ());
 	auto weight (node.ledger.weight (transaction, rep));
 	auto should_process (false);
-	if (node.network_params.is_test_network () || weight > supply / 1000) // 0.1% or above
+	if (node.network_params.network.is_test_network () || weight > supply / 1000) // 0.1% or above
 	{
 		unsigned int cooldown;
 		if (weight < supply / 100) // 0.1% to 1%
@@ -2768,7 +2768,7 @@ void nano::active_transactions::confirm_frontiers (nano::transaction const & tra
 	~15 minutes for non-representative nodes, 3 minutes for representatives */
 	int representative_factor = representative ? 3 * 60 : 15 * 60;
 	// Decrease check time for test network
-	int test_network_factor = node.network_params.is_test_network () ? 1000 : 1;
+	int test_network_factor = node.network_params.network.is_test_network () ? 1000 : 1;
 	if (std::chrono::steady_clock::now () >= next_frontier_check)
 	{
 		size_t max_elections (max_broadcast_queue / 4);
@@ -2876,7 +2876,7 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
 				/* Escalation for long unconfirmed elections
 				Start new elections for previous block & source
 				if there are less than 100 active elections */
-				if (election_l->announcements % announcement_long == 1 && roots_size < 100 && !node.network_params.is_test_network ())
+				if (election_l->announcements % announcement_long == 1 && roots_size < 100 && !node.network_params.network.is_test_network ())
 				{
 					std::shared_ptr<nano::block> previous;
 					auto previous_hash (election_l->status.winner->previous ());
@@ -2949,7 +2949,7 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
 				if ((!rep_channels->empty () && node.rep_crawler.total_weight () > node.config.online_weight_minimum.number ()) || roots_size > 5)
 				{
 					// broadcast_confirm_req_base modifies reps, so we clone it once to avoid aliasing
-					if (!node.network_params.is_test_network ())
+					if (!node.network_params.network.is_test_network ())
 					{
 						if (confirm_req_bundle.size () < max_broadcast_queue)
 						{
@@ -2980,7 +2980,7 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
 				}
 				else
 				{
-					if (!node.network_params.is_test_network ())
+					if (!node.network_params.network.is_test_network ())
 					{
 						auto deque_l (node.network.udp_channels.random_set (100));
 						auto vec (std::make_shared<std::vector<std::shared_ptr<nano::transport::channel>>> ());
@@ -3020,7 +3020,7 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
 		node.network.flood_block_batch (rebroadcast_bundle);
 	}
 	// Batch confirmation request
-	if (!node.network_params.is_live_network () && !requests_bundle.empty ())
+	if (!node.network_params.network.is_live_network () && !requests_bundle.empty ())
 	{
 		node.network.broadcast_confirm_req_batch (requests_bundle, 50);
 	}
@@ -3068,7 +3068,7 @@ void nano::active_transactions::request_loop ()
 	{
 		request_confirm (lock);
 		const auto extra_delay (std::min (roots.size (), max_broadcast_queue) * node.network.broadcast_interval_ms * 2);
-		condition.wait_for (lock, std::chrono::milliseconds (node.network_params.request_interval_ms + extra_delay));
+		condition.wait_for (lock, std::chrono::milliseconds (node.network_params.network.request_interval_ms + extra_delay));
 	}
 }
 
@@ -3241,9 +3241,9 @@ void nano::active_transactions::adjust_difficulty (nano::block_hash const & hash
 		uint64_t average (static_cast<uint64_t> (sum / elections_list.size ()));
 		// Potential overflow check
 		uint64_t divider (1);
-		if (elections_list.size () > 1000000 && (average - node.network_params.publish_threshold) > elections_list.size ())
+		if (elections_list.size () > 1000000 && (average - node.network_params.network.publish_threshold) > elections_list.size ())
 		{
-			divider = ((average - node.network_params.publish_threshold) / elections_list.size ()) + 1;
+			divider = ((average - node.network_params.network.publish_threshold) / elections_list.size ()) + 1;
 		}
 		// Set adjusted difficulty
 		for (auto & item : elections_list)
diff --git a/nano/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp
index 79c4f5e6..5d449191 100644
--- a/nano/node/nodeconfig.cpp
+++ b/nano/node/nodeconfig.cpp
@@ -26,12 +26,12 @@ logging (logging_a)
 	// which is determined at node startup based on active network.
 	if (peering_port == 0)
 	{
-		peering_port = network_params.default_node_port;
+		peering_port = network_params.network.default_node_port;
 	}
 	const char * epoch_message ("epoch v1 block");
 	strncpy ((char *)epoch_block_link.bytes.data (), epoch_message, epoch_block_link.bytes.size ());
 	epoch_block_signer = network_params.ledger.genesis_account;
-	switch (network_params.network ())
+	switch (network_params.network.network ())
 	{
 		case nano::nano_networks::nano_test_network:
 			enable_voting = true;
diff --git a/nano/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp
index 71609a1b..c7298e7e 100644
--- a/nano/node/nodeconfig.hpp
+++ b/nano/node/nodeconfig.hpp
@@ -9,6 +9,7 @@
 #include <nano/node/logging.hpp>
 #include <nano/node/stats.hpp>
 #include <nano/node/websocketconfig.hpp>
+#include <nano/secure/common.hpp>
 #include <vector>
 
 namespace nano
@@ -49,7 +50,7 @@ public:
 	uint16_t callback_port{ 0 };
 	std::string callback_target;
 	int lmdb_max_dbs{ 128 };
-	bool allow_local_peers{ !network_params.is_live_network () }; // disable by default for live network
+	bool allow_local_peers{ !network_params.network.is_live_network () }; // disable by default for live network
 	nano::stat_config stat_config;
 	nano::ipc::ipc_config ipc_config;
 	nano::uint256_union epoch_block_link;
diff --git a/nano/node/portmapping.cpp b/nano/node/portmapping.cpp
index 16548661..0b8f7089 100644
--- a/nano/node/portmapping.cpp
+++ b/nano/node/portmapping.cpp
@@ -20,7 +20,7 @@ void nano::port_mapping::start ()
 
 void nano::port_mapping::refresh_devices ()
 {
-	if (!network_params.is_test_network ())
+	if (!network_params.network.is_test_network ())
 	{
 		std::lock_guard<std::mutex> lock (mutex);
 		int discover_error = 0;
@@ -50,7 +50,7 @@ void nano::port_mapping::refresh_devices ()
 
 void nano::port_mapping::refresh_mapping ()
 {
-	if (!network_params.is_test_network ())
+	if (!network_params.network.is_test_network ())
 	{
 		std::lock_guard<std::mutex> lock (mutex);
 		auto node_port (std::to_string (node.network.endpoint ().port ()));
@@ -80,7 +80,7 @@ void nano::port_mapping::refresh_mapping ()
 int nano::port_mapping::check_mapping ()
 {
 	int result (3600);
-	if (!network_params.is_test_network ())
+	if (!network_params.network.is_test_network ())
 	{
 		// Long discovery time and fast setup/teardown make this impractical for testing
 		std::lock_guard<std::mutex> lock (mutex);
diff --git a/nano/node/rpc.cpp b/nano/node/rpc.cpp
index 12a7f968..61b180a4 100644
--- a/nano/node/rpc.cpp
+++ b/nano/node/rpc.cpp
@@ -4253,7 +4253,7 @@ void nano::rpc_handler::work_generate ()
 {
 	rpc_control_impl ();
 	auto hash (hash_impl ());
-	uint64_t difficulty (node.network_params.publish_threshold);
+	uint64_t difficulty (node.network_params.network.publish_threshold);
 	boost::optional<std::string> difficulty_text (request.get_optional<std::string> ("difficulty"));
 	if (!ec && difficulty_text.is_initialized ())
 	{
@@ -4352,7 +4352,7 @@ void nano::rpc_handler::work_validate ()
 {
 	auto hash (hash_impl ());
 	auto work (work_optional_impl ());
-	uint64_t difficulty (node.network_params.publish_threshold);
+	uint64_t difficulty (node.network_params.network.publish_threshold);
 	boost::optional<std::string> difficulty_text (request.get_optional<std::string> ("difficulty"));
 	if (!ec && difficulty_text.is_initialized ())
 	{
@@ -4468,7 +4468,7 @@ void nano::rpc_connection::read ()
 	std::promise<size_t> header_available_promise;
 	std::future<size_t> header_available = header_available_promise.get_future ();
 	header_parser->body_limit (rpc.config.max_request_size);
-	if (!node->network_params.is_test_network ())
+	if (!node->network_params.network.is_test_network ())
 	{
 		boost::beast::http::async_read_header (socket, buffer, *header_parser, [this_l, header_parser, &header_available_promise, &header_error](boost::system::error_code const & ec, size_t bytes_transferred) {
 			size_t header_response_bytes_written = 0;
diff --git a/nano/node/rpcconfig.cpp b/nano/node/rpcconfig.cpp
index 5e0e131c..acca075b 100644
--- a/nano/node/rpcconfig.cpp
+++ b/nano/node/rpcconfig.cpp
@@ -34,7 +34,7 @@ nano::error nano::rpc_secure_config::deserialize_json (nano::jsonconfig & json)
 
 nano::rpc_config::rpc_config (bool enable_control_a) :
 address (boost::asio::ip::address_v6::loopback ()),
-port (network_params.default_rpc_port),
+port (network_constants.default_rpc_port),
 enable_control (enable_control_a),
 max_json_depth (20),
 enable_sign_hash (false),
diff --git a/nano/node/rpcconfig.hpp b/nano/node/rpcconfig.hpp
index be80bbd3..8c9eafa0 100644
--- a/nano/node/rpcconfig.hpp
+++ b/nano/node/rpcconfig.hpp
@@ -2,6 +2,7 @@
 
 #include <boost/asio.hpp>
 #include <nano/lib/errors.hpp>
+#include <nano/secure/common.hpp>
 #include <string>
 
 namespace nano
@@ -38,7 +39,7 @@ public:
 	rpc_config (bool = false);
 	nano::error serialize_json (nano::jsonconfig &) const;
 	nano::error deserialize_json (bool & upgraded_a, nano::jsonconfig &);
-	nano::network_params network_params;
+	nano::network_constants network_constants;
 	boost::asio::ip::address_v6 address;
 	uint16_t port;
 	bool enable_control;
diff --git a/nano/node/transport/udp.cpp b/nano/node/transport/udp.cpp
index 5995e997..fef0b488 100644
--- a/nano/node/transport/udp.cpp
+++ b/nano/node/transport/udp.cpp
@@ -581,7 +581,7 @@ bool nano::transport::udp_channels::not_a_peer (nano::endpoint const & endpoint_
 	{
 		result = true;
 	}
-	else if (!network_params.is_test_network () && max_ip_connections (endpoint_a))
+	else if (!network_params.network.is_test_network () && max_ip_connections (endpoint_a))
 	{
 		result = true;
 	}
diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp
index b923e641..57ed52e8 100644
--- a/nano/node/wallet.cpp
+++ b/nano/node/wallet.cpp
@@ -1335,7 +1335,7 @@ void nano::wallet::work_cache_blocking (nano::account const & account_a, nano::b
 		 * The difficulty parameter is the second parameter for `work_generate_blocking()`,
 		 * currently we don't supply one so we must fetch the default value.
 		 */
-		auto difficulty (wallets.node.network_params.publish_threshold);
+		auto difficulty (wallets.node.network_params.network.publish_threshold);
 
 		wallets.node.logger.try_log ("Work generation for ", root_a.to_string (), ", with a difficulty of ", difficulty, " complete: ", (std::chrono::duration_cast<std::chrono::microseconds> (std::chrono::steady_clock::now () - begin).count ()), " us");
 	}
@@ -1662,7 +1662,7 @@ void nano::wallets::ongoing_compute_reps ()
 {
 	compute_reps ();
 	auto & node_l (node);
-	auto compute_delay (network_params.is_test_network () ? std::chrono::milliseconds (10) : std::chrono::milliseconds (15 * 60 * 1000)); // Representation drifts quickly on the test network but very slowly on the live network
+	auto compute_delay (network_params.network.is_test_network () ? std::chrono::milliseconds (10) : std::chrono::milliseconds (15 * 60 * 1000)); // Representation drifts quickly on the test network but very slowly on the live network
 	node.alarm.add (std::chrono::steady_clock::now () + compute_delay, [&node_l]() {
 		node_l.wallets.ongoing_compute_reps ();
 	});
diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp
index 7b27a7a3..c4ab4828 100644
--- a/nano/qt/qt.cpp
+++ b/nano/qt/qt.cpp
@@ -73,11 +73,11 @@ wallet (wallet_a)
 {
 	your_account_label->setStyleSheet ("font-weight: bold;");
 	std::string network = "Live";
-	if (wallet.node.network_params.is_beta_network ())
+	if (wallet.node.network_params.network.is_beta_network ())
 	{
 		network = "Beta";
 	}
-	else if (wallet.node.network_params.is_test_network ())
+	else if (wallet.node.network_params.network.is_test_network ())
 	{
 		network = "Test";
 	}
diff --git a/nano/qt_system/entry.cpp b/nano/qt_system/entry.cpp
index 1726649a..23475f38 100644
--- a/nano/qt_system/entry.cpp
+++ b/nano/qt_system/entry.cpp
@@ -6,7 +6,7 @@
 
 int main (int argc, char ** argv)
 {
-	nano::network_params::set_active_network (nano::nano_networks::nano_test_network);
+	nano::network_constants::set_active_network (nano::nano_networks::nano_test_network);
 	QApplication application (argc, argv);
 	QCoreApplication::setOrganizationName ("Nano");
 	QCoreApplication::setOrganizationDomain ("nano.org");
diff --git a/nano/qt_test/entry.cpp b/nano/qt_test/entry.cpp
index a9043b43..823a3f60 100644
--- a/nano/qt_test/entry.cpp
+++ b/nano/qt_test/entry.cpp
@@ -2,11 +2,14 @@
 #include <gtest/gtest.h>
 
 QApplication * test_application = nullptr;
-extern void force_nano_test_network ();
+namespace nano
+{
+void force_nano_test_network ();
+}
 
 int main (int argc, char ** argv)
 {
-	force_nano_test_network ();
+	nano::force_nano_test_network ();
 	QApplication application (argc, argv);
 	test_application = &application;
 	testing::InitGoogleTest (&argc, argv);
diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp
index dff2de00..930d7a29 100644
--- a/nano/secure/common.cpp
+++ b/nano/secure/common.cpp
@@ -1,9 +1,8 @@
-#include <nano/secure/common.hpp>
-
 #include <nano/lib/interface.h>
 #include <nano/lib/numbers.hpp>
 #include <nano/node/common.hpp>
 #include <nano/secure/blockstore.hpp>
+#include <nano/secure/common.hpp>
 #include <nano/secure/versioning.hpp>
 
 #include <boost/endian/conversion.hpp>
@@ -11,6 +10,11 @@
 
 #include <queue>
 
+#include <iostream>
+#include <limits>
+#include <nano/core_test/testutil.hpp>
+#include <nano/lib/config.hpp>
+
 #include <crypto/ed25519-donna/ed25519.h>
 
 size_t constexpr nano::send_block::size;
@@ -19,6 +23,134 @@ size_t constexpr nano::open_block::size;
 size_t constexpr nano::change_block::size;
 size_t constexpr nano::state_block::size;
 
+nano::nano_networks nano::network_constants::active_network = nano::nano_networks::ACTIVE_NETWORK;
+
+namespace
+{
+char const * test_private_key_data = "34F0A37AAD20F4A260F0A5B3CB3D7FB50673212263E58A380BC10474BB039CE4";
+char const * test_public_key_data = "B0311EA55708D6A53C75CDBF88300259C6D018522FE3D4D0A242E431F9E8B6D0"; // xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpiij4txtdo
+char const * beta_public_key_data = "A59A47CC4F593E75AE9AD653FDA9358E2F7898D9ACC8C60E80D0495CE20FBA9F"; // xrb_3betaz86ypbygpqbookmzpnmd5jhh4efmd8arr9a3n4bdmj1zgnzad7xpmfp
+char const * live_public_key_data = "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA"; // xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3
+char const * test_genesis_data = R"%%%({
+	"type": "open",
+	"source": "B0311EA55708D6A53C75CDBF88300259C6D018522FE3D4D0A242E431F9E8B6D0",
+	"representative": "xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpiij4txtdo",
+	"account": "xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpiij4txtdo",
+	"work": "9680625b39d3363d",
+	"signature": "ECDA914373A2F0CA1296475BAEE40500A7F0A7AD72A5A80C81D7FAB7F6C802B2CC7DB50F5DD0FB25B2EF11761FA7344A158DD5A700B21BD47DE5BD0F63153A02"
+	})%%%";
+
+char const * beta_genesis_data = R"%%%({
+	"type": "open",
+	"source": "A59A47CC4F593E75AE9AD653FDA9358E2F7898D9ACC8C60E80D0495CE20FBA9F",
+	"representative": "xrb_3betaz86ypbygpqbookmzpnmd5jhh4efmd8arr9a3n4bdmj1zgnzad7xpmfp",
+	"account": "xrb_3betaz86ypbygpqbookmzpnmd5jhh4efmd8arr9a3n4bdmj1zgnzad7xpmfp",
+	"work": "000000000f0aaeeb",
+	"signature": "A726490E3325E4FA59C1C900D5B6EEBB15FE13D99F49D475B93F0AACC5635929A0614CF3892764A04D1C6732A0D716FFEB254D4154C6F544D11E6630F201450B"
+	})%%%";
+
+char const * live_genesis_data = R"%%%({
+	"type": "open",
+	"source": "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA",
+	"representative": "xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3",
+	"account": "xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3",
+	"work": "62f05417dd3fb691",
+	"signature": "9F0C933C8ADE004D808EA1985FA746A7E95BA2A38F867640F53EC8F180BDFE9E2C1268DEAD7C2664F356E37ABA362BC58E46DBA03E523A7B5A19E4B6EB12BB02"
+	})%%%";
+}
+
+nano::network_params::network_params () :
+network_params (network_constants::active_network)
+{
+}
+
+nano::network_params::network_params (nano::nano_networks network_a) :
+network (network_a), ledger (network), voting (network), node (network), portmapping (network), bootstrap (network)
+{
+	unsigned constexpr kdf_full_work = 64 * 1024;
+	unsigned constexpr kdf_test_work = 8;
+	kdf_work = network.is_test_network () ? kdf_test_work : kdf_full_work;
+	header_magic_number = network.is_test_network () ? std::array<uint8_t, 2>{ { 'R', 'A' } } : network.is_beta_network () ? std::array<uint8_t, 2>{ { 'R', 'B' } } : std::array<uint8_t, 2>{ { 'R', 'C' } };
+}
+
+nano::ledger_constants::ledger_constants (nano::network_constants & network_constants) :
+ledger_constants (network_constants.network ())
+{
+}
+
+nano::ledger_constants::ledger_constants (nano::nano_networks network_a) :
+zero_key ("0"),
+test_genesis_key (test_private_key_data),
+nano_test_account (test_public_key_data),
+nano_beta_account (beta_public_key_data),
+nano_live_account (live_public_key_data),
+nano_test_genesis (test_genesis_data),
+nano_beta_genesis (beta_genesis_data),
+nano_live_genesis (live_genesis_data),
+genesis_account (network_a == nano::nano_networks::nano_test_network ? nano_test_account : network_a == nano::nano_networks::nano_beta_network ? nano_beta_account : nano_live_account),
+genesis_block (network_a == nano::nano_networks::nano_test_network ? nano_test_genesis : network_a == nano::nano_networks::nano_beta_network ? nano_beta_genesis : nano_live_genesis),
+genesis_amount (std::numeric_limits<nano::uint128_t>::max ()),
+burn_account (0),
+not_an_account_m (0)
+{
+}
+
+nano::account const & nano::ledger_constants::not_an_account ()
+{
+	if (not_an_account_m.is_zero ())
+	{
+		// Randomly generating these mean no two nodes will ever have the same sentinel values which protects against some insecure algorithms
+		nano::random_pool::generate_block (not_an_account_m.bytes.data (), not_an_account_m.bytes.size ());
+	}
+	return not_an_account_m;
+}
+
+nano::node_constants::node_constants (nano::network_constants & network_constants)
+{
+	period = network_constants.is_test_network () ? std::chrono::seconds (1) : std::chrono::seconds (60);
+	cutoff = period * 5;
+	syn_cookie_cutoff = std::chrono::seconds (5);
+	backup_interval = std::chrono::minutes (5);
+	search_pending_interval = network_constants.is_test_network () ? std::chrono::seconds (1) : std::chrono::seconds (5 * 60);
+	peer_interval = search_pending_interval;
+	unchecked_cleaning_interval = std::chrono::hours (2);
+	process_confirmed_interval = network_constants.is_test_network () ? std::chrono::milliseconds (50) : std::chrono::milliseconds (500);
+	max_weight_samples = network_constants.is_live_network () ? 4032 : 864;
+	weight_period = 5 * 60; // 5 minutes
+}
+
+nano::voting_constants::voting_constants (nano::network_constants & network_constants)
+{
+	max_cache = network_constants.is_test_network () ? 2 : 1000;
+	generator_delay = network_constants.is_test_network () ? std::chrono::milliseconds (10) : std::chrono::milliseconds (500);
+}
+
+nano::portmapping_constants::portmapping_constants (nano::network_constants & network_constants)
+{
+	mapping_timeout = network_constants.is_test_network () ? 53 : 3593;
+	check_timeout = network_constants.is_test_network () ? 17 : 53;
+}
+
+nano::bootstrap_constants::bootstrap_constants (nano::network_constants & network_constants)
+{
+	lazy_max_pull_blocks = network_constants.is_test_network () ? 2 : 512;
+}
+
+/* Convenience constants for core_test which is always on the test network */
+namespace
+{
+nano::ledger_constants test_constants (nano::nano_networks::nano_test_network);
+}
+
+nano::keypair const & nano::zero_key (test_constants.zero_key);
+nano::keypair const & nano::test_genesis_key (test_constants.test_genesis_key);
+nano::account const & nano::nano_test_account (test_constants.nano_test_account);
+std::string const & nano::nano_test_genesis (test_constants.nano_test_genesis);
+nano::account const & nano::genesis_account (test_constants.genesis_account);
+std::string const & nano::genesis_block (test_constants.genesis_block);
+nano::uint128_t const & nano::genesis_amount (test_constants.genesis_amount);
+nano::account const & nano::burn_account (test_constants.burn_account);
+
 // Create a new random keypair
 nano::keypair::keypair ()
 {
diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp
index 1111aca1..49f9e854 100644
--- a/nano/secure/common.hpp
+++ b/nano/secure/common.hpp
@@ -2,6 +2,8 @@
 
 #include <nano/lib/blockbuilders.hpp>
 #include <nano/lib/blocks.hpp>
+#include <nano/lib/config.hpp>
+#include <nano/lib/numbers.hpp>
 #include <nano/lib/utility.hpp>
 #include <nano/secure/utility.hpp>
 
@@ -307,4 +309,96 @@ public:
 	nano::block_hash hash () const;
 	std::shared_ptr<nano::block> open;
 };
+
+class network_params;
+
+/** Genesis keys and ledger constants for network variants */
+class ledger_constants
+{
+public:
+	ledger_constants (nano::network_constants & network_constants);
+	ledger_constants (nano::nano_networks network_a);
+	nano::keypair zero_key;
+	nano::keypair test_genesis_key;
+	nano::account nano_test_account;
+	nano::account nano_beta_account;
+	nano::account nano_live_account;
+	std::string nano_test_genesis;
+	std::string nano_beta_genesis;
+	std::string nano_live_genesis;
+	nano::account genesis_account;
+	std::string genesis_block;
+	nano::uint128_t genesis_amount;
+	nano::account const & not_an_account ();
+	nano::account burn_account;
+
+private:
+	nano::account not_an_account_m;
+};
+
+/** Node related constants whose value depends on the active network */
+class node_constants
+{
+public:
+	node_constants (nano::network_constants & network_constants);
+	std::chrono::seconds period;
+	std::chrono::seconds cutoff;
+	std::chrono::seconds syn_cookie_cutoff;
+	std::chrono::minutes backup_interval;
+	std::chrono::seconds search_pending_interval;
+	std::chrono::seconds peer_interval;
+	std::chrono::hours unchecked_cleaning_interval;
+	std::chrono::milliseconds process_confirmed_interval;
+
+	/** The maximum amount of samples for a 2 week period on live or 3 days on beta */
+	uint64_t max_weight_samples;
+	uint64_t weight_period;
+};
+
+/** Voting related constants whose value depends on the active network */
+class voting_constants
+{
+public:
+	voting_constants (nano::network_constants & network_constants);
+	size_t max_cache;
+	std::chrono::milliseconds generator_delay;
+};
+
+/** Port-mapping related constants whose value depends on the active network */
+class portmapping_constants
+{
+public:
+	portmapping_constants (nano::network_constants & network_constants);
+	// Timeouts are primes so they infrequently happen at the same time
+	int mapping_timeout;
+	int check_timeout;
+};
+
+/** Bootstrap related constants whose value depends on the active network */
+class bootstrap_constants
+{
+public:
+	bootstrap_constants (nano::network_constants & network_constants);
+	uint64_t lazy_max_pull_blocks;
+};
+
+/** Constants whose value depends on the active network */
+class network_params
+{
+public:
+	/** Populate values based on the current active network */
+	network_params ();
+
+	/** Populate values based on \p network_a */
+	network_params (nano::nano_networks network_a);
+
+	std::array<uint8_t, 2> header_magic_number;
+	unsigned kdf_work;
+	network_constants network;
+	ledger_constants ledger;
+	voting_constants voting;
+	node_constants node;
+	portmapping_constants portmapping;
+	bootstrap_constants bootstrap;
+};
 }
diff --git a/nano/secure/utility.cpp b/nano/secure/utility.cpp
index c4ee2bac..3b0898b1 100644
--- a/nano/secure/utility.cpp
+++ b/nano/secure/utility.cpp
@@ -7,9 +7,9 @@ static std::vector<boost::filesystem::path> all_unique_paths;
 
 boost::filesystem::path nano::working_path (bool legacy)
 {
-	static nano::network_params network_params;
+	static nano::network_constants network_constants;
 	auto result (nano::app_path ());
-	switch (network_params.network ())
+	switch (network_constants.network ())
 	{
 		case nano::nano_networks::nano_test_network:
 			if (!legacy)