diff --git a/.clang-format.base b/.clang-format.base
index 862f03ff4d..a1e26efb78 100644
--- a/.clang-format.base
+++ b/.clang-format.base
@@ -7,22 +7,23 @@ Standard:        Cpp11
 TabWidth:        4
 IndentWidth: 4
 PointerAlignment: Middle
-UseTab: ForIndentation
+UseTab: ForContinuationAndIndentation
 BreakBeforeBraces: Custom
 AlignEscapedNewlines: Left
 AllowShortBlocksOnASingleLine: false
 AllowShortCaseLabelsOnASingleLine: false
 AllowShortFunctionsOnASingleLine: false
+AllowShortLambdasOnASingleLine: All
 AllowShortLoopsOnASingleLine: false
 BreakConstructorInitializersBeforeComma: true
 BreakConstructorInitializers: AfterColon
 ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ConstructorInitializerIndentWidth: 0
 ContinuationIndentWidth: 0
 KeepEmptyLinesAtTheStartOfBlocks: false
 IndentCaseLabels: true
 SpaceBeforeCpp11BracedList: false
 BraceWrapping:
+  AfterCaseLabel: true
   AfterEnum: true
   AfterStruct: true
   SplitEmptyFunction: true
@@ -33,6 +34,7 @@ BraceWrapping:
   AfterClass: true
   BeforeCatch: true
   BeforeElse: true
+  BeforeLambdaBody: true
   SplitEmptyRecord: true
   SplitEmptyNamespace: true
 SortIncludes: true
diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp
index d43d870166..0bf209f46a 100644
--- a/nano/core_test/active_transactions.cpp
+++ b/nano/core_test/active_transactions.cpp
@@ -19,12 +19,12 @@ TEST (active_transactions, confirm_active)
 	auto & node1 = *system.add_node (node_flags);
 	nano::genesis genesis;
 	auto send = nano::send_block_builder ()
-	            .previous (genesis.hash ())
-	            .destination (nano::public_key ())
-	            .balance (nano::genesis_amount - 100)
-	            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	            .work (*system.work.generate (genesis.hash ()))
-	            .build_shared ();
+				.previous (genesis.hash ())
+				.destination (nano::public_key ())
+				.balance (nano::genesis_amount - 100)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*system.work.generate (genesis.hash ()))
+				.build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node1.process (*send).code);
 	nano::node_config node_config2 (nano::get_available_port (), system.logging);
 	node_config2.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
@@ -90,14 +90,14 @@ TEST (active_transactions, confirm_frontier)
 	nano::genesis genesis;
 	nano::state_block_builder builder;
 	auto send = builder
-	            .account (nano::dev_genesis_key.pub)
-	            .previous (genesis.hash ())
-	            .representative (nano::dev_genesis_key.pub)
-	            .balance (nano::genesis_amount - 100)
-	            .link (nano::public_key ())
-	            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	            .work (*system.work.generate (genesis.hash ()))
-	            .build_shared ();
+				.account (nano::dev_genesis_key.pub)
+				.previous (genesis.hash ())
+				.representative (nano::dev_genesis_key.pub)
+				.balance (nano::genesis_amount - 100)
+				.link (nano::public_key ())
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*system.work.generate (genesis.hash ()))
+				.build_shared ();
 	auto send_copy = builder.make_block ().from (*send).build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node1.process (*send).code);
 	node1.confirmation_height_processor.add (send);
@@ -144,32 +144,32 @@ TEST (active_transactions, keep_local)
 	ASSERT_TIMELY (5s, node.active.empty ());
 	nano::state_block_builder builder;
 	auto open1 = builder.make_block ()
-	             .account (key1.pub)
-	             .previous (0)
-	             .representative (key1.pub)
-	             .balance (node.config.receive_minimum.number ())
-	             .link (send1->hash ())
-	             .sign (key1.prv, key1.pub)
-	             .work (*system.work.generate (key1.pub))
-	             .build_shared ();
+				 .account (key1.pub)
+				 .previous (0)
+				 .representative (key1.pub)
+				 .balance (node.config.receive_minimum.number ())
+				 .link (send1->hash ())
+				 .sign (key1.prv, key1.pub)
+				 .work (*system.work.generate (key1.pub))
+				 .build_shared ();
 	auto open2 = builder.make_block ()
-	             .account (key2.pub)
-	             .previous (0)
-	             .representative (key2.pub)
-	             .balance (node.config.receive_minimum.number ())
-	             .link (send2->hash ())
-	             .sign (key2.prv, key2.pub)
-	             .work (*system.work.generate (key2.pub))
-	             .build_shared ();
+				 .account (key2.pub)
+				 .previous (0)
+				 .representative (key2.pub)
+				 .balance (node.config.receive_minimum.number ())
+				 .link (send2->hash ())
+				 .sign (key2.prv, key2.pub)
+				 .work (*system.work.generate (key2.pub))
+				 .build_shared ();
 	auto open3 = builder.make_block ()
-	             .account (key3.pub)
-	             .previous (0)
-	             .representative (key3.pub)
-	             .balance (node.config.receive_minimum.number ())
-	             .link (send3->hash ())
-	             .sign (key3.prv, key3.pub)
-	             .work (*system.work.generate (key3.pub))
-	             .build_shared ();
+				 .account (key3.pub)
+				 .previous (0)
+				 .representative (key3.pub)
+				 .balance (node.config.receive_minimum.number ())
+				 .link (send3->hash ())
+				 .sign (key3.prv, key3.pub)
+				 .work (*system.work.generate (key3.pub))
+				 .build_shared ();
 	node.process_active (open1);
 	node.process_active (open2);
 	node.process_active (open3);
@@ -186,12 +186,12 @@ TEST (active_transactions, inactive_votes_cache)
 	nano::block_hash latest (node.latest (nano::dev_genesis_key.pub));
 	nano::keypair key;
 	auto send = nano::send_block_builder ()
-	            .previous (latest)
-	            .destination (key.pub)
-	            .balance (nano::genesis_amount - 100)
-	            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	            .work (*system.work.generate (latest))
-	            .build_shared ();
+				.previous (latest)
+				.destination (key.pub)
+				.balance (nano::genesis_amount - 100)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*system.work.generate (latest))
+				.build_shared ();
 	auto vote (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), std::vector<nano::block_hash> (1, send->hash ())));
 	node.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node));
 	ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 1);
@@ -209,19 +209,19 @@ TEST (active_transactions, inactive_votes_cache_fork)
 	nano::keypair key;
 	nano::send_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .previous (latest)
-	             .destination (key.pub)
-	             .balance (nano::genesis_amount - 100)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (latest))
-	             .build_shared ();
+				 .previous (latest)
+				 .destination (key.pub)
+				 .balance (nano::genesis_amount - 100)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (latest))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .previous (latest)
-	             .destination (key.pub)
-	             .balance (nano::genesis_amount - 200)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (latest))
-	             .build_shared ();
+				 .previous (latest)
+				 .destination (key.pub)
+				 .balance (nano::genesis_amount - 200)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (latest))
+				 .build_shared ();
 	auto vote (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), std::vector<nano::block_hash> (1, send1->hash ())));
 	node.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node));
 	auto channel1 (node.network.udp_channels.create (node.network.endpoint ()));
@@ -252,21 +252,21 @@ TEST (active_transactions, inactive_votes_cache_existing_vote)
 	nano::keypair key;
 	nano::block_builder builder;
 	auto send = builder.send ()
-	            .previous (latest)
-	            .destination (key.pub)
-	            .balance (nano::genesis_amount - 100 * nano::Gxrb_ratio)
-	            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	            .work (*system.work.generate (latest))
-	            .build_shared ();
+				.previous (latest)
+				.destination (key.pub)
+				.balance (nano::genesis_amount - 100 * nano::Gxrb_ratio)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*system.work.generate (latest))
+				.build_shared ();
 	auto open = builder.state ()
-	            .account (key.pub)
-	            .previous (0)
-	            .representative (key.pub)
-	            .balance (100 * nano::Gxrb_ratio)
-	            .link (send->hash ())
-	            .sign (key.prv, key.pub)
-	            .work (*system.work.generate (key.pub))
-	            .build_shared ();
+				.account (key.pub)
+				.previous (0)
+				.representative (key.pub)
+				.balance (100 * nano::Gxrb_ratio)
+				.link (send->hash ())
+				.sign (key.prv, key.pub)
+				.work (*system.work.generate (key.pub))
+				.build_shared ();
 	node.process_active (send);
 	node.block_processor.add (open);
 	node.block_processor.flush ();
@@ -309,28 +309,28 @@ TEST (active_transactions, inactive_votes_cache_multiple_votes)
 	nano::keypair key1;
 	nano::block_builder builder;
 	auto send1 = builder.send ()
-	             .previous (latest)
-	             .destination (key1.pub)
-	             .balance (nano::genesis_amount - 100 * nano::Gxrb_ratio)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (latest))
-	             .build_shared ();
+				 .previous (latest)
+				 .destination (key1.pub)
+				 .balance (nano::genesis_amount - 100 * nano::Gxrb_ratio)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (latest))
+				 .build_shared ();
 	auto send2 = builder.send ()
-	             .previous (send1->hash ())
-	             .destination (key1.pub)
-	             .balance (100 * nano::Gxrb_ratio)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send1->hash ()))
-	             .build_shared ();
+				 .previous (send1->hash ())
+				 .destination (key1.pub)
+				 .balance (100 * nano::Gxrb_ratio)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send1->hash ()))
+				 .build_shared ();
 	auto open = builder.state ()
-	            .account (key1.pub)
-	            .previous (0)
-	            .representative (key1.pub)
-	            .balance (100 * nano::Gxrb_ratio)
-	            .link (send1->hash ())
-	            .sign (key1.prv, key1.pub)
-	            .work (*system.work.generate (key1.pub))
-	            .build_shared ();
+				.account (key1.pub)
+				.previous (0)
+				.representative (key1.pub)
+				.balance (100 * nano::Gxrb_ratio)
+				.link (send1->hash ())
+				.sign (key1.prv, key1.pub)
+				.work (*system.work.generate (key1.pub))
+				.build_shared ();
 	node.block_processor.add (send1);
 	node.block_processor.add (send2);
 	node.block_processor.add (open);
@@ -362,85 +362,85 @@ TEST (active_transactions, inactive_votes_cache_election_start)
 	nano::send_block_builder send_block_builder;
 	nano::state_block_builder state_block_builder;
 	auto send1 = send_block_builder.make_block ()
-	             .previous (latest)
-	             .destination (key1.pub)
-	             .balance (nano::genesis_amount - 2000 * nano::Gxrb_ratio)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (latest))
-	             .build_shared ();
+				 .previous (latest)
+				 .destination (key1.pub)
+				 .balance (nano::genesis_amount - 2000 * nano::Gxrb_ratio)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (latest))
+				 .build_shared ();
 	auto send2 = send_block_builder.make_block ()
-	             .previous (send1->hash ())
-	             .destination (key2.pub)
-	             .balance (nano::genesis_amount - 4000 * nano::Gxrb_ratio)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send1->hash ()))
-	             .build_shared ();
+				 .previous (send1->hash ())
+				 .destination (key2.pub)
+				 .balance (nano::genesis_amount - 4000 * nano::Gxrb_ratio)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send1->hash ()))
+				 .build_shared ();
 	auto send3 = send_block_builder.make_block ()
-	             .previous (send2->hash ())
-	             .destination (key3.pub)
-	             .balance (nano::genesis_amount - 6000 * nano::Gxrb_ratio)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send2->hash ()))
-	             .build_shared ();
+				 .previous (send2->hash ())
+				 .destination (key3.pub)
+				 .balance (nano::genesis_amount - 6000 * nano::Gxrb_ratio)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send2->hash ()))
+				 .build_shared ();
 	auto send4 = send_block_builder.make_block ()
-	             .previous (send3->hash ())
-	             .destination (key4.pub)
-	             .balance (nano::genesis_amount - 8000 * nano::Gxrb_ratio)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send3->hash ()))
-	             .build_shared ();
+				 .previous (send3->hash ())
+				 .destination (key4.pub)
+				 .balance (nano::genesis_amount - 8000 * nano::Gxrb_ratio)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send3->hash ()))
+				 .build_shared ();
 	auto send5 = send_block_builder.make_block ()
-	             .previous (send4->hash ())
-	             .destination (key5.pub)
-	             .balance (nano::genesis_amount - 10000 * nano::Gxrb_ratio)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send4->hash ()))
-	             .build_shared ();
+				 .previous (send4->hash ())
+				 .destination (key5.pub)
+				 .balance (nano::genesis_amount - 10000 * nano::Gxrb_ratio)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send4->hash ()))
+				 .build_shared ();
 	auto open1 = state_block_builder.make_block ()
-	             .account (key1.pub)
-	             .previous (0)
-	             .representative (key1.pub)
-	             .balance (2000 * nano::Gxrb_ratio)
-	             .link (send1->hash ())
-	             .sign (key1.prv, key1.pub)
-	             .work (*system.work.generate (key1.pub))
-	             .build_shared ();
+				 .account (key1.pub)
+				 .previous (0)
+				 .representative (key1.pub)
+				 .balance (2000 * nano::Gxrb_ratio)
+				 .link (send1->hash ())
+				 .sign (key1.prv, key1.pub)
+				 .work (*system.work.generate (key1.pub))
+				 .build_shared ();
 	auto open2 = state_block_builder.make_block ()
-	             .account (key2.pub)
-	             .previous (0)
-	             .representative (key2.pub)
-	             .balance (2000 * nano::Gxrb_ratio)
-	             .link (send2->hash ())
-	             .sign (key2.prv, key2.pub)
-	             .work (*system.work.generate (key2.pub))
-	             .build_shared ();
+				 .account (key2.pub)
+				 .previous (0)
+				 .representative (key2.pub)
+				 .balance (2000 * nano::Gxrb_ratio)
+				 .link (send2->hash ())
+				 .sign (key2.prv, key2.pub)
+				 .work (*system.work.generate (key2.pub))
+				 .build_shared ();
 	auto open3 = state_block_builder.make_block ()
-	             .account (key3.pub)
-	             .previous (0)
-	             .representative (key3.pub)
-	             .balance (2000 * nano::Gxrb_ratio)
-	             .link (send3->hash ())
-	             .sign (key3.prv, key3.pub)
-	             .work (*system.work.generate (key3.pub))
-	             .build_shared ();
+				 .account (key3.pub)
+				 .previous (0)
+				 .representative (key3.pub)
+				 .balance (2000 * nano::Gxrb_ratio)
+				 .link (send3->hash ())
+				 .sign (key3.prv, key3.pub)
+				 .work (*system.work.generate (key3.pub))
+				 .build_shared ();
 	auto open4 = state_block_builder.make_block ()
-	             .account (key4.pub)
-	             .previous (0)
-	             .representative (key4.pub)
-	             .balance (2000 * nano::Gxrb_ratio)
-	             .link (send4->hash ())
-	             .sign (key4.prv, key4.pub)
-	             .work (*system.work.generate (key4.pub))
-	             .build_shared ();
+				 .account (key4.pub)
+				 .previous (0)
+				 .representative (key4.pub)
+				 .balance (2000 * nano::Gxrb_ratio)
+				 .link (send4->hash ())
+				 .sign (key4.prv, key4.pub)
+				 .work (*system.work.generate (key4.pub))
+				 .build_shared ();
 	auto open5 = state_block_builder.make_block ()
-	             .account (key5.pub)
-	             .previous (0)
-	             .representative (key5.pub)
-	             .balance (2000 * nano::Gxrb_ratio)
-	             .link (send5->hash ())
-	             .sign (key5.prv, key5.pub)
-	             .work (*system.work.generate (key5.pub))
-	             .build_shared ();
+				 .account (key5.pub)
+				 .previous (0)
+				 .representative (key5.pub)
+				 .balance (2000 * nano::Gxrb_ratio)
+				 .link (send5->hash ())
+				 .sign (key5.prv, key5.pub)
+				 .work (*system.work.generate (key5.pub))
+				 .build_shared ();
 	node.block_processor.add (send1);
 	node.block_processor.add (send2);
 	node.block_processor.add (send3);
@@ -457,19 +457,19 @@ TEST (active_transactions, inactive_votes_cache_election_start)
 	ASSERT_EQ (1, node.ledger.cache.cemented_count);
 	// These blocks will be processed later
 	auto send6 = send_block_builder.make_block ()
-	             .previous (send5->hash ())
-	             .destination (nano::keypair ().pub)
-	             .balance (send5->balance ().number () - 1)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send5->hash ()))
-	             .build_shared ();
+				 .previous (send5->hash ())
+				 .destination (nano::keypair ().pub)
+				 .balance (send5->balance ().number () - 1)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send5->hash ()))
+				 .build_shared ();
 	auto send7 = send_block_builder.make_block ()
-	             .previous (send6->hash ())
-	             .destination (nano::keypair ().pub)
-	             .balance (send6->balance ().number () - 1)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send6->hash ()))
-	             .build_shared ();
+				 .previous (send6->hash ())
+				 .destination (nano::keypair ().pub)
+				 .balance (send6->balance ().number () - 1)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send6->hash ()))
+				 .build_shared ();
 	// Inactive votes
 	std::vector<nano::block_hash> hashes{ open1->hash (), open2->hash (), open3->hash (), open4->hash (), open5->hash (), send7->hash () };
 	auto vote1 (std::make_shared<nano::vote> (key1.pub, key1.prv, 0, hashes));
@@ -522,25 +522,25 @@ TEST (active_transactions, DISABLED_update_difficulty)
 	// Generate blocks & start elections
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 100)
-	             .link (key1.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 100)
+				 .link (key1.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	auto difficulty1 (send1->difficulty ());
 	auto multiplier1 (nano::normalized_multiplier (nano::difficulty::to_multiplier (difficulty1, nano::work_threshold (send1->work_version (), nano::block_details (nano::epoch::epoch_0, true, false, false))), node1.network_params.network.publish_thresholds.epoch_1));
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send1->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 200)
-	             .link (key1.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send1->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send1->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 200)
+				 .link (key1.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send1->hash ()))
+				 .build_shared ();
 	auto difficulty2 (send2->difficulty ());
 	auto multiplier2 (nano::normalized_multiplier (nano::difficulty::to_multiplier (difficulty2, nano::work_threshold (send2->work_version (), nano::block_details (nano::epoch::epoch_0, true, false, false))), node1.network_params.network.publish_thresholds.epoch_1));
 	node1.process_active (send1);
@@ -604,24 +604,24 @@ TEST (active_transactions, vote_replays)
 	nano::keypair key;
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .link (key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .link (key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	ASSERT_NE (nullptr, send1);
 	auto open1 = builder.make_block ()
-	             .account (key.pub)
-	             .previous (0)
-	             .representative (key.pub)
-	             .balance (nano::Gxrb_ratio)
-	             .link (send1->hash ())
-	             .sign (key.prv, key.pub)
-	             .work (*system.work.generate (key.pub))
-	             .build_shared ();
+				 .account (key.pub)
+				 .previous (0)
+				 .representative (key.pub)
+				 .balance (nano::Gxrb_ratio)
+				 .link (send1->hash ())
+				 .sign (key.prv, key.pub)
+				 .work (*system.work.generate (key.pub))
+				 .build_shared ();
 	ASSERT_NE (nullptr, open1);
 	node.process_active (send1);
 	node.process_active (open1);
@@ -645,14 +645,14 @@ TEST (active_transactions, vote_replays)
 	ASSERT_EQ (nano::Gxrb_ratio, node.ledger.weight (key.pub));
 
 	auto send2 = builder.make_block ()
-	             .account (key.pub)
-	             .previous (open1->hash ())
-	             .representative (key.pub)
-	             .balance (nano::Gxrb_ratio - 1)
-	             .link (key.pub)
-	             .sign (key.prv, key.pub)
-	             .work (*system.work.generate (open1->hash ()))
-	             .build_shared ();
+				 .account (key.pub)
+				 .previous (open1->hash ())
+				 .representative (key.pub)
+				 .balance (nano::Gxrb_ratio - 1)
+				 .link (key.pub)
+				 .sign (key.prv, key.pub)
+				 .work (*system.work.generate (open1->hash ()))
+				 .build_shared ();
 	ASSERT_NE (nullptr, send2);
 	node.process_active (send2);
 	nano::blocks_confirm (node, { send2 });
@@ -759,14 +759,14 @@ TEST (active_transactions, republish_winner)
 	nano::keypair key;
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .link (key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .link (key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 
 	node1.process_active (send1);
 	node1.block_processor.flush ();
@@ -776,14 +776,14 @@ TEST (active_transactions, republish_winner)
 	for (auto i (0); i < 5; i++)
 	{
 		auto fork = builder.make_block ()
-		            .account (nano::dev_genesis_key.pub)
-		            .previous (genesis.hash ())
-		            .representative (nano::dev_genesis_key.pub)
-		            .balance (nano::genesis_amount - 1 - i)
-		            .link (key.pub)
-		            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		            .work (*system.work.generate (genesis.hash ()))
-		            .build_shared ();
+					.account (nano::dev_genesis_key.pub)
+					.previous (genesis.hash ())
+					.representative (nano::dev_genesis_key.pub)
+					.balance (nano::genesis_amount - 1 - i)
+					.link (key.pub)
+					.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					.work (*system.work.generate (genesis.hash ()))
+					.build_shared ();
 		node1.process_active (fork);
 	}
 	node1.block_processor.flush ();
@@ -792,14 +792,14 @@ TEST (active_transactions, republish_winner)
 
 	// Process new fork with vote to change winner
 	auto fork = builder.make_block ()
-	            .account (nano::dev_genesis_key.pub)
-	            .previous (genesis.hash ())
-	            .representative (nano::dev_genesis_key.pub)
-	            .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
-	            .link (key.pub)
-	            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	            .work (*system.work.generate (genesis.hash ()))
-	            .build_shared ();
+				.account (nano::dev_genesis_key.pub)
+				.previous (genesis.hash ())
+				.representative (nano::dev_genesis_key.pub)
+				.balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
+				.link (key.pub)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*system.work.generate (genesis.hash ()))
+				.build_shared ();
 
 	node1.process_active (fork);
 	node1.block_processor.flush ();
@@ -825,14 +825,14 @@ TEST (active_transactions, fork_filter_cleanup)
 	nano::keypair key;
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .link (key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .link (key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	std::vector<uint8_t> block_bytes;
 	{
 		nano::vectorstream stream (block_bytes);
@@ -843,14 +843,14 @@ TEST (active_transactions, fork_filter_cleanup)
 	for (auto i (0); i < 10; i++)
 	{
 		auto fork = builder.make_block ()
-		            .account (nano::dev_genesis_key.pub)
-		            .previous (genesis.hash ())
-		            .representative (nano::dev_genesis_key.pub)
-		            .balance (nano::genesis_amount - 1 - i)
-		            .link (key.pub)
-		            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		            .work (*system.work.generate (genesis.hash ()))
-		            .build_shared ();
+					.account (nano::dev_genesis_key.pub)
+					.previous (genesis.hash ())
+					.representative (nano::dev_genesis_key.pub)
+					.balance (nano::genesis_amount - 1 - i)
+					.link (key.pub)
+					.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					.work (*system.work.generate (genesis.hash ()))
+					.build_shared ();
 		node1.process_active (fork);
 		node1.block_processor.flush ();
 		node1.scheduler.flush ();
@@ -894,25 +894,25 @@ TEST (active_transactions, fork_replacement_tally)
 	{
 		balance -= amount + i;
 		auto send = builder.make_block ()
-		            .account (nano::dev_genesis_key.pub)
-		            .previous (latest)
-		            .representative (nano::dev_genesis_key.pub)
-		            .balance (balance)
-		            .link (keys[i].pub)
-		            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		            .work (*system.work.generate (latest))
-		            .build_shared ();
+					.account (nano::dev_genesis_key.pub)
+					.previous (latest)
+					.representative (nano::dev_genesis_key.pub)
+					.balance (balance)
+					.link (keys[i].pub)
+					.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					.work (*system.work.generate (latest))
+					.build_shared ();
 		node1.process_active (send);
 		latest = send->hash ();
 		auto open = builder.make_block ()
-		            .account (keys[i].pub)
-		            .previous (0)
-		            .representative (keys[i].pub)
-		            .balance (amount + i)
-		            .link (send->hash ())
-		            .sign (keys[i].prv, keys[i].pub)
-		            .work (*system.work.generate (keys[i].pub))
-		            .build_shared ();
+					.account (keys[i].pub)
+					.previous (0)
+					.representative (keys[i].pub)
+					.balance (amount + i)
+					.link (send->hash ())
+					.sign (keys[i].prv, keys[i].pub)
+					.work (*system.work.generate (keys[i].pub))
+					.build_shared ();
 		node1.process_active (open);
 		// Confirmation
 		auto vote (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), std::vector<nano::block_hash>{ send->hash (), open->hash () }));
@@ -923,27 +923,27 @@ TEST (active_transactions, fork_replacement_tally)
 
 	nano::keypair key;
 	auto send_last = builder.make_block ()
-	                 .account (nano::dev_genesis_key.pub)
-	                 .previous (latest)
-	                 .representative (nano::dev_genesis_key.pub)
-	                 .balance (balance - 2 * nano::Gxrb_ratio)
-	                 .link (key.pub)
-	                 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                 .work (*system.work.generate (latest))
-	                 .build_shared ();
+					 .account (nano::dev_genesis_key.pub)
+					 .previous (latest)
+					 .representative (nano::dev_genesis_key.pub)
+					 .balance (balance - 2 * nano::Gxrb_ratio)
+					 .link (key.pub)
+					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					 .work (*system.work.generate (latest))
+					 .build_shared ();
 
 	// Forks without votes
 	for (auto i (0); i < reps_count; i++)
 	{
 		auto fork = builder.make_block ()
-		            .account (nano::dev_genesis_key.pub)
-		            .previous (latest)
-		            .representative (nano::dev_genesis_key.pub)
-		            .balance (balance - nano::Gxrb_ratio - i)
-		            .link (key.pub)
-		            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		            .work (*system.work.generate (latest))
-		            .build_shared ();
+					.account (nano::dev_genesis_key.pub)
+					.previous (latest)
+					.representative (nano::dev_genesis_key.pub)
+					.balance (balance - nano::Gxrb_ratio - i)
+					.link (key.pub)
+					.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					.work (*system.work.generate (latest))
+					.build_shared ();
 		node1.process_active (fork);
 	}
 	node1.block_processor.flush ();
@@ -957,14 +957,14 @@ TEST (active_transactions, fork_replacement_tally)
 	for (auto i (0); i < reps_count; i++)
 	{
 		auto fork = builder.make_block ()
-		            .account (nano::dev_genesis_key.pub)
-		            .previous (latest)
-		            .representative (nano::dev_genesis_key.pub)
-		            .balance (balance - 1 - i)
-		            .link (key.pub)
-		            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		            .work (*system.work.generate (latest))
-		            .build_shared ();
+					.account (nano::dev_genesis_key.pub)
+					.previous (latest)
+					.representative (nano::dev_genesis_key.pub)
+					.balance (balance - 1 - i)
+					.link (key.pub)
+					.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					.work (*system.work.generate (latest))
+					.build_shared ();
 		auto vote (std::make_shared<nano::vote> (keys[i].pub, keys[i].prv, 0, std::vector<nano::block_hash>{ fork->hash () }));
 		node1.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node1));
 		node1.vote_processor.flush ();
@@ -1058,68 +1058,68 @@ TEST (active_transactions, insertion_prioritization)
 	auto & node = *system.add_node (node_config, node_flags);
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::genesis_hash)
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 10 * nano::xrb_ratio)
-	             .link (nano::public_key ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (nano::genesis_hash))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::genesis_hash)
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 10 * nano::xrb_ratio)
+				 .link (nano::public_key ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (nano::genesis_hash))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send1->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 20 * nano::xrb_ratio)
-	             .link (nano::public_key ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send1->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send1->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 20 * nano::xrb_ratio)
+				 .link (nano::public_key ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send1->hash ()))
+				 .build_shared ();
 	auto send3 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send2->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 30 * nano::xrb_ratio)
-	             .link (nano::public_key ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send2->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send2->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 30 * nano::xrb_ratio)
+				 .link (nano::public_key ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send2->hash ()))
+				 .build_shared ();
 	auto send4 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send3->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 40 * nano::xrb_ratio)
-	             .link (nano::public_key ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send3->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send3->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 40 * nano::xrb_ratio)
+				 .link (nano::public_key ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send3->hash ()))
+				 .build_shared ();
 	auto send5 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send4->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 50 * nano::xrb_ratio)
-	             .link (nano::public_key ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send4->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send4->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 50 * nano::xrb_ratio)
+				 .link (nano::public_key ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send4->hash ()))
+				 .build_shared ();
 	auto send6 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send5->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 60 * nano::xrb_ratio)
-	             .link (nano::public_key ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send5->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send5->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 60 * nano::xrb_ratio)
+				 .link (nano::public_key ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send5->hash ()))
+				 .build_shared ();
 	auto send7 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send6->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 70 * nano::xrb_ratio)
-	             .link (nano::public_key ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send6->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send6->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 70 * nano::xrb_ratio)
+				 .link (nano::public_key ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send6->hash ()))
+				 .build_shared ();
 	// Sort by difficulty, descending
 	std::vector<std::shared_ptr<nano::block>> blocks{ send1, send2, send3, send4, send5, send6, send7 };
 	for (auto const & block : blocks)
@@ -1264,14 +1264,14 @@ TEST (active_transactions, election_difficulty_update_old)
 	nano::keypair key;
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 10 * nano::xrb_ratio)
-	             .link (key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 10 * nano::xrb_ratio)
+				 .link (key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	auto send1_copy = builder.make_block ().from (*send1).build_shared ();
 	node.process_active (send1);
 	node.block_processor.flush ();
@@ -1313,32 +1313,32 @@ TEST (active_transactions, election_difficulty_update_fork)
 	nano::keypair key;
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (epoch2->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .link (key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (epoch2->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (epoch2->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .link (key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (epoch2->hash ()))
+				 .build_shared ();
 	auto open1 = builder.make_block ()
-	             .account (key.pub)
-	             .previous (0)
-	             .representative (key.pub)
-	             .balance (nano::Gxrb_ratio)
-	             .link (send1->hash ())
-	             .sign (key.prv, key.pub)
-	             .work (*system.work.generate (key.pub))
-	             .build_shared ();
+				 .account (key.pub)
+				 .previous (0)
+				 .representative (key.pub)
+				 .balance (nano::Gxrb_ratio)
+				 .link (send1->hash ())
+				 .sign (key.prv, key.pub)
+				 .work (*system.work.generate (key.pub))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send1->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
-	             .link (key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send1->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send1->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
+				 .link (key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send1->hash ()))
+				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.process (*send1).code);
 	ASSERT_EQ (nano::process_result::progress, node.process (*open1).code);
 	ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
@@ -1356,32 +1356,32 @@ TEST (active_transactions, election_difficulty_update_fork)
 	// Verify an election with multiple blocks is correctly updated on arrival of another block
 	// Each subsequent block has difficulty at least higher than the previous one
 	auto fork_change = builder.make_block ()
-	                   .account (key.pub)
-	                   .previous (open1->hash ())
-	                   .representative (nano::dev_genesis_key.pub)
-	                   .balance (nano::Gxrb_ratio)
-	                   .link (0)
-	                   .sign (key.prv, key.pub)
-	                   .work (*system.work.generate (open1->hash ()))
-	                   .build_shared ();
+					   .account (key.pub)
+					   .previous (open1->hash ())
+					   .representative (nano::dev_genesis_key.pub)
+					   .balance (nano::Gxrb_ratio)
+					   .link (0)
+					   .sign (key.prv, key.pub)
+					   .work (*system.work.generate (open1->hash ()))
+					   .build_shared ();
 	auto fork_send = builder.make_block ()
-	                 .account (key.pub)
-	                 .previous (open1->hash ())
-	                 .representative (key.pub)
-	                 .balance (0)
-	                 .link (key.pub)
-	                 .sign (key.prv, key.pub)
-	                 .work (*system.work.generate (open1->hash (), fork_change->difficulty ()))
-	                 .build_shared ();
+					 .account (key.pub)
+					 .previous (open1->hash ())
+					 .representative (key.pub)
+					 .balance (0)
+					 .link (key.pub)
+					 .sign (key.prv, key.pub)
+					 .work (*system.work.generate (open1->hash (), fork_change->difficulty ()))
+					 .build_shared ();
 	auto fork_receive = builder.make_block ()
-	                    .account (key.pub)
-	                    .previous (open1->hash ())
-	                    .representative (key.pub)
-	                    .balance (2 * nano::Gxrb_ratio)
-	                    .link (send2->hash ())
-	                    .sign (key.prv, key.pub)
-	                    .work (*system.work.generate (open1->hash (), fork_send->difficulty ()))
-	                    .build_shared ();
+						.account (key.pub)
+						.previous (open1->hash ())
+						.representative (key.pub)
+						.balance (2 * nano::Gxrb_ratio)
+						.link (send2->hash ())
+						.sign (key.prv, key.pub)
+						.work (*system.work.generate (open1->hash (), fork_send->difficulty ()))
+						.build_shared ();
 	ASSERT_GT (fork_send->difficulty (), fork_change->difficulty ());
 	ASSERT_GT (fork_receive->difficulty (), fork_send->difficulty ());
 
@@ -1428,12 +1428,12 @@ TEST (active_transactions, confirm_new)
 	auto & node1 = *system.nodes[0];
 	nano::genesis genesis;
 	auto send = nano::send_block_builder ()
-	            .previous (genesis.hash ())
-	            .destination (nano::public_key ())
-	            .balance (nano::genesis_amount - 100)
-	            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	            .work (*system.work.generate (genesis.hash ()))
-	            .build_shared ();
+				.previous (genesis.hash ())
+				.destination (nano::public_key ())
+				.balance (nano::genesis_amount - 100)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*system.work.generate (genesis.hash ()))
+				.build_shared ();
 	node1.process_active (send);
 	node1.block_processor.flush ();
 	node1.scheduler.flush ();
@@ -1455,14 +1455,14 @@ TEST (active_transactions, restart_dropped)
 	auto & node = *system.add_node (node_config);
 	nano::genesis genesis;
 	auto send = nano::state_block_builder ()
-	            .account (nano::dev_genesis_key.pub)
-	            .previous (genesis.hash ())
-	            .representative (nano::dev_genesis_key.pub)
-	            .balance (nano::genesis_amount - nano::xrb_ratio)
-	            .link (nano::dev_genesis_key.pub)
-	            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	            .work (*system.work.generate (genesis.hash ()))
-	            .build_shared (); // Process only in ledger and simulate dropping the election
+				.account (nano::dev_genesis_key.pub)
+				.previous (genesis.hash ())
+				.representative (nano::dev_genesis_key.pub)
+				.balance (nano::genesis_amount - nano::xrb_ratio)
+				.link (nano::dev_genesis_key.pub)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*system.work.generate (genesis.hash ()))
+				.build_shared (); // Process only in ledger and simulate dropping the election
 	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
 	// Generate higher difficulty work
 	ASSERT_TRUE (node.work_generate_blocking (*send, send->difficulty () + 1).is_initialized ());
@@ -1512,23 +1512,23 @@ TEST (active_transactions, conflicting_block_vote_existing_election)
 	nano::keypair key;
 	nano::state_block_builder builder;
 	auto send = builder.make_block ()
-	            .account (nano::dev_genesis_key.pub)
-	            .previous (genesis.hash ())
-	            .representative (nano::dev_genesis_key.pub)
-	            .balance (nano::genesis_amount - 100)
-	            .link (key.pub)
-	            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	            .work (*system.work.generate (genesis.hash ()))
-	            .build_shared ();
+				.account (nano::dev_genesis_key.pub)
+				.previous (genesis.hash ())
+				.representative (nano::dev_genesis_key.pub)
+				.balance (nano::genesis_amount - 100)
+				.link (key.pub)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*system.work.generate (genesis.hash ()))
+				.build_shared ();
 	auto fork = builder.make_block ()
-	            .account (nano::dev_genesis_key.pub)
-	            .previous (genesis.hash ())
-	            .representative (nano::dev_genesis_key.pub)
-	            .balance (nano::genesis_amount - 200)
-	            .link (key.pub)
-	            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	            .work (*system.work.generate (genesis.hash ()))
-	            .build_shared ();
+				.account (nano::dev_genesis_key.pub)
+				.previous (genesis.hash ())
+				.representative (nano::dev_genesis_key.pub)
+				.balance (nano::genesis_amount - 200)
+				.link (key.pub)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*system.work.generate (genesis.hash ()))
+				.build_shared ();
 	auto vote_fork (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), fork));
 
 	ASSERT_EQ (nano::process_result::progress, node.process_local (send).code);
@@ -1558,50 +1558,50 @@ TEST (active_transactions, activate_account_chain)
 	nano::keypair key;
 	nano::state_block_builder builder;
 	auto send = builder.make_block ()
-	            .account (nano::dev_genesis_key.pub)
-	            .previous (nano::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))
-	            .build ();
+				.account (nano::dev_genesis_key.pub)
+				.previous (nano::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))
+				.build ();
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .link (key.pub)
-	             .balance (nano::genesis_amount - 2)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send->hash ()))
-	             .build ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .link (key.pub)
+				 .balance (nano::genesis_amount - 2)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send->hash ()))
+				 .build ();
 	auto send3 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send2->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .link (key.pub)
-	             .balance (nano::genesis_amount - 3)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send2->hash ()))
-	             .build ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send2->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .link (key.pub)
+				 .balance (nano::genesis_amount - 3)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send2->hash ()))
+				 .build ();
 	auto open = builder.make_block ()
-	            .account (key.pub)
-	            .previous (0)
-	            .representative (key.pub)
-	            .link (send2->hash ())
-	            .balance (1)
-	            .sign (key.prv, key.pub)
-	            .work (*system.work.generate (key.pub))
-	            .build ();
+				.account (key.pub)
+				.previous (0)
+				.representative (key.pub)
+				.link (send2->hash ())
+				.balance (1)
+				.sign (key.prv, key.pub)
+				.work (*system.work.generate (key.pub))
+				.build ();
 	auto receive = builder.make_block ()
-	               .account (key.pub)
-	               .previous (open->hash ())
-	               .representative (key.pub)
-	               .link (send3->hash ())
-	               .balance (2)
-	               .sign (key.prv, key.pub)
-	               .work (*system.work.generate (open->hash ()))
-	               .build ();
+				   .account (key.pub)
+				   .previous (open->hash ())
+				   .representative (key.pub)
+				   .link (send3->hash ())
+				   .balance (2)
+				   .sign (key.prv, key.pub)
+				   .work (*system.work.generate (open->hash ()))
+				   .build ();
 	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
 	ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
 	ASSERT_EQ (nano::process_result::progress, node.process (*send3).code);
@@ -1658,32 +1658,32 @@ TEST (active_transactions, activate_inactive)
 	nano::keypair key;
 	nano::state_block_builder builder;
 	auto send = builder.make_block ()
-	            .account (nano::dev_genesis_key.pub)
-	            .previous (nano::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))
-	            .build_shared ();
+				.account (nano::dev_genesis_key.pub)
+				.previous (nano::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))
+				.build_shared ();
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .link (nano::keypair ().pub)
-	             .balance (nano::genesis_amount - 2)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .link (nano::keypair ().pub)
+				 .balance (nano::genesis_amount - 2)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send->hash ()))
+				 .build_shared ();
 	auto open = builder.make_block ()
-	            .account (key.pub)
-	            .previous (0)
-	            .representative (key.pub)
-	            .link (send->hash ())
-	            .balance (1)
-	            .sign (key.prv, key.pub)
-	            .work (*system.work.generate (key.pub))
-	            .build_shared ();
+				.account (key.pub)
+				.previous (0)
+				.representative (key.pub)
+				.link (send->hash ())
+				.balance (1)
+				.sign (key.prv, key.pub)
+				.work (*system.work.generate (key.pub))
+				.build_shared ();
 
 	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
 	ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
@@ -1732,38 +1732,38 @@ TEST (active_transactions, pessimistic_elections)
 	nano::keypair key;
 	nano::state_block_builder builder;
 	auto send = builder.make_block ()
-	            .account (nano::dev_genesis_key.pub)
-	            .previous (nano::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))
-	            .build_shared ();
+				.account (nano::dev_genesis_key.pub)
+				.previous (nano::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))
+				.build_shared ();
 
 	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
 
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .link (key.pub)
-	             .balance (nano::genesis_amount - 2)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send->hash ()))
-	             .build ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .link (key.pub)
+				 .balance (nano::genesis_amount - 2)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send->hash ()))
+				 .build ();
 
 	ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
 
 	auto open = builder.make_block ()
-	            .account (key.pub)
-	            .previous (0)
-	            .representative (key.pub)
-	            .link (send2->hash ())
-	            .balance (1)
-	            .sign (key.prv, key.pub)
-	            .work (*system.work.generate (key.pub))
-	            .build_shared ();
+				.account (key.pub)
+				.previous (0)
+				.representative (key.pub)
+				.link (send2->hash ())
+				.balance (1)
+				.sign (key.prv, key.pub)
+				.work (*system.work.generate (key.pub))
+				.build_shared ();
 
 	ASSERT_EQ (nano::process_result::progress, node.process (*open).code);
 
@@ -1871,38 +1871,38 @@ TEST (active_transactions, list_active)
 	nano::keypair key;
 	nano::state_block_builder builder;
 	auto send = builder.make_block ()
-	            .account (nano::dev_genesis_key.pub)
-	            .previous (nano::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))
-	            .build_shared ();
+				.account (nano::dev_genesis_key.pub)
+				.previous (nano::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))
+				.build_shared ();
 
 	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
 
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .link (key.pub)
-	             .balance (nano::genesis_amount - 2)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .link (key.pub)
+				 .balance (nano::genesis_amount - 2)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send->hash ()))
+				 .build_shared ();
 
 	ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
 
 	auto open = builder.make_block ()
-	            .account (key.pub)
-	            .previous (0)
-	            .representative (key.pub)
-	            .link (send2->hash ())
-	            .balance (1)
-	            .sign (key.prv, key.pub)
-	            .work (*system.work.generate (key.pub))
-	            .build_shared ();
+				.account (key.pub)
+				.previous (0)
+				.representative (key.pub)
+				.link (send2->hash ())
+				.balance (1)
+				.sign (key.prv, key.pub)
+				.work (*system.work.generate (key.pub))
+				.build_shared ();
 
 	ASSERT_EQ (nano::process_result::progress, node.process (*open).code);
 
@@ -1931,14 +1931,14 @@ TEST (active_transactions, vacancy)
 	auto & node = *system.add_node (config);
 	nano::state_block_builder builder;
 	auto send = builder.make_block ()
-	            .account (nano::dev_genesis_key.pub)
-	            .previous (nano::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))
-	            .build_shared ();
+				.account (nano::dev_genesis_key.pub)
+				.previous (nano::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))
+				.build_shared ();
 	std::atomic<bool> updated = false;
 	node.active.vacancy_update = [&updated] () { updated = true; };
 	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
diff --git a/nano/core_test/block.cpp b/nano/core_test/block.cpp
index 6d4874bad1..88b8766d31 100644
--- a/nano/core_test/block.cpp
+++ b/nano/core_test/block.cpp
@@ -462,13 +462,13 @@ TEST (block_builder, from)
 	std::error_code ec;
 	nano::block_builder builder;
 	auto block = builder
-	             .state ()
-	             .account_address ("xrb_15nhh1kzw3x8ohez6s75wy3jr6dqgq65oaede1fzk5hqxk4j8ehz7iqtb3to")
-	             .previous_hex ("FEFBCE274E75148AB31FF63EFB3082EF1126BF72BF3FA9C76A97FD5A9F0EBEC5")
-	             .balance_dec ("2251569974100400000000000000000000")
-	             .representative_address ("xrb_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou")
-	             .link_hex ("E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86")
-	             .build (ec);
+				 .state ()
+				 .account_address ("xrb_15nhh1kzw3x8ohez6s75wy3jr6dqgq65oaede1fzk5hqxk4j8ehz7iqtb3to")
+				 .previous_hex ("FEFBCE274E75148AB31FF63EFB3082EF1126BF72BF3FA9C76A97FD5A9F0EBEC5")
+				 .balance_dec ("2251569974100400000000000000000000")
+				 .representative_address ("xrb_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou")
+				 .link_hex ("E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86")
+				 .build (ec);
 	ASSERT_EQ (block->hash ().to_string (), "2D243F8F92CDD0AD94A1D456A6B15F3BE7A6FCBD98D4C5831D06D15C818CD81F");
 
 	auto block2 = builder.state ().from (*block).build (ec);
@@ -495,13 +495,13 @@ TEST (block_builder, state)
 	std::error_code ec;
 	nano::block_builder builder;
 	auto block = builder
-	             .state ()
-	             .account_address ("xrb_15nhh1kzw3x8ohez6s75wy3jr6dqgq65oaede1fzk5hqxk4j8ehz7iqtb3to")
-	             .previous_hex ("FEFBCE274E75148AB31FF63EFB3082EF1126BF72BF3FA9C76A97FD5A9F0EBEC5")
-	             .balance_dec ("2251569974100400000000000000000000")
-	             .representative_address ("xrb_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou")
-	             .link_hex ("E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86")
-	             .build (ec);
+				 .state ()
+				 .account_address ("xrb_15nhh1kzw3x8ohez6s75wy3jr6dqgq65oaede1fzk5hqxk4j8ehz7iqtb3to")
+				 .previous_hex ("FEFBCE274E75148AB31FF63EFB3082EF1126BF72BF3FA9C76A97FD5A9F0EBEC5")
+				 .balance_dec ("2251569974100400000000000000000000")
+				 .representative_address ("xrb_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou")
+				 .link_hex ("E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86")
+				 .build (ec);
 	ASSERT_EQ (block->hash ().to_string (), "2D243F8F92CDD0AD94A1D456A6B15F3BE7A6FCBD98D4C5831D06D15C818CD81F");
 	ASSERT_TRUE (block->source ().is_zero ());
 	ASSERT_TRUE (block->destination ().is_zero ());
@@ -514,14 +514,14 @@ TEST (block_builder, state_missing_rep)
 	std::error_code ec;
 	nano::block_builder builder;
 	auto block = builder
-	             .state ()
-	             .account_address ("xrb_15nhh1kzw3x8ohez6s75wy3jr6dqgq65oaede1fzk5hqxk4j8ehz7iqtb3to")
-	             .previous_hex ("FEFBCE274E75148AB31FF63EFB3082EF1126BF72BF3FA9C76A97FD5A9F0EBEC5")
-	             .balance_dec ("2251569974100400000000000000000000")
-	             .link_hex ("E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86")
-	             .sign_zero ()
-	             .work (0)
-	             .build (ec);
+				 .state ()
+				 .account_address ("xrb_15nhh1kzw3x8ohez6s75wy3jr6dqgq65oaede1fzk5hqxk4j8ehz7iqtb3to")
+				 .previous_hex ("FEFBCE274E75148AB31FF63EFB3082EF1126BF72BF3FA9C76A97FD5A9F0EBEC5")
+				 .balance_dec ("2251569974100400000000000000000000")
+				 .link_hex ("E16DD58C1EFA8B521545B0A74375AA994D9FC43828A4266D75ECF57F07A7EE86")
+				 .sign_zero ()
+				 .work (0)
+				 .build (ec);
 	ASSERT_EQ (ec, nano::error_common::missing_representative);
 }
 
@@ -536,15 +536,15 @@ TEST (block_builder, state_equality)
 
 	// With builder
 	auto block2 = builder
-	              .state ()
-	              .account (key1.pub)
-	              .previous (1)
-	              .representative (key2.pub)
-	              .balance (2)
-	              .link (4)
-	              .sign (key1.prv, key1.pub)
-	              .work (5)
-	              .build (ec);
+				  .state ()
+				  .account (key1.pub)
+				  .previous (1)
+				  .representative (key2.pub)
+				  .balance (2)
+				  .link (4)
+				  .sign (key1.prv, key1.pub)
+				  .work (5)
+				  .build (ec);
 
 	ASSERT_NO_ERROR (ec);
 	ASSERT_EQ (block1.hash (), block2->hash ());
@@ -570,11 +570,11 @@ TEST (block_builder, open)
 	std::error_code ec;
 	nano::block_builder builder;
 	auto block = builder
-	             .open ()
-	             .account_address ("xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3")
-	             .representative_address ("xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3")
-	             .source_hex ("E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA")
-	             .build (ec);
+				 .open ()
+				 .account_address ("xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3")
+				 .representative_address ("xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3")
+				 .source_hex ("E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA")
+				 .build (ec);
 	ASSERT_EQ (block->hash ().to_string (), "991CF190094C00F0B68E2E5F75F6BEE95A2E0BD93CEAA4A6734DB9F19B728948");
 	ASSERT_EQ (block->source ().to_string (), "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA");
 	ASSERT_TRUE (block->destination ().is_zero ());
@@ -592,13 +592,13 @@ TEST (block_builder, open_equality)
 
 	// With builder
 	auto block2 = builder
-	              .open ()
-	              .source (1)
-	              .account (key2.pub)
-	              .representative (key1.pub)
-	              .sign (key1.prv, key1.pub)
-	              .work (5)
-	              .build (ec);
+				  .open ()
+				  .source (1)
+				  .account (key2.pub)
+				  .representative (key1.pub)
+				  .sign (key1.prv, key1.pub)
+				  .work (5)
+				  .build (ec);
 
 	ASSERT_NO_ERROR (ec);
 	ASSERT_EQ (block1.hash (), block2->hash ());
@@ -610,10 +610,10 @@ TEST (block_builder, change)
 	std::error_code ec;
 	nano::block_builder builder;
 	auto block = builder
-	             .change ()
-	             .representative_address ("xrb_3rropjiqfxpmrrkooej4qtmm1pueu36f9ghinpho4esfdor8785a455d16nf")
-	             .previous_hex ("088EE46429CA936F76C4EAA20B97F6D33E5D872971433EE0C1311BCB98764456")
-	             .build (ec);
+				 .change ()
+				 .representative_address ("xrb_3rropjiqfxpmrrkooej4qtmm1pueu36f9ghinpho4esfdor8785a455d16nf")
+				 .previous_hex ("088EE46429CA936F76C4EAA20B97F6D33E5D872971433EE0C1311BCB98764456")
+				 .build (ec);
 	ASSERT_EQ (block->hash ().to_string (), "13552AC3928E93B5C6C215F61879358E248D4A5246B8B3D1EEC5A566EDCEE077");
 	ASSERT_TRUE (block->source ().is_zero ());
 	ASSERT_TRUE (block->destination ().is_zero ());
@@ -631,12 +631,12 @@ TEST (block_builder, change_equality)
 
 	// With builder
 	auto block2 = builder
-	              .change ()
-	              .previous (1)
-	              .representative (key1.pub)
-	              .sign (key1.prv, key1.pub)
-	              .work (5)
-	              .build (ec);
+				  .change ()
+				  .previous (1)
+				  .representative (key1.pub)
+				  .sign (key1.prv, key1.pub)
+				  .work (5)
+				  .build (ec);
 
 	ASSERT_NO_ERROR (ec);
 	ASSERT_EQ (block1.hash (), block2->hash ());
@@ -648,11 +648,11 @@ TEST (block_builder, send)
 	std::error_code ec;
 	nano::block_builder builder;
 	auto block = builder
-	             .send ()
-	             .destination_address ("xrb_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb")
-	             .previous_hex ("F685856D73A488894F7F3A62BC3A88E17E985F9969629FF3FDD4A0D4FD823F24")
-	             .balance_hex ("00F035A9C7D818E7C34148C524FFFFEE")
-	             .build (ec);
+				 .send ()
+				 .destination_address ("xrb_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb")
+				 .previous_hex ("F685856D73A488894F7F3A62BC3A88E17E985F9969629FF3FDD4A0D4FD823F24")
+				 .balance_hex ("00F035A9C7D818E7C34148C524FFFFEE")
+				 .build (ec);
 	ASSERT_EQ (block->hash ().to_string (), "4560E7B1F3735D082700CFC2852F5D1F378F7418FD24CEF1AD45AB69316F15CD");
 	ASSERT_TRUE (block->source ().is_zero ());
 	ASSERT_EQ (block->destination ().to_account (), "nano_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb");
@@ -670,13 +670,13 @@ TEST (block_builder, send_equality)
 
 	// With builder
 	auto block2 = builder
-	              .send ()
-	              .previous (1)
-	              .destination (key1.pub)
-	              .balance (2)
-	              .sign (key1.prv, key1.pub)
-	              .work (5)
-	              .build (ec);
+				  .send ()
+				  .previous (1)
+				  .destination (key1.pub)
+				  .balance (2)
+				  .sign (key1.prv, key1.pub)
+				  .work (5)
+				  .build (ec);
 
 	ASSERT_NO_ERROR (ec);
 	ASSERT_EQ (block1.hash (), block2->hash ());
@@ -694,12 +694,12 @@ TEST (block_builder, receive_equality)
 
 	// With builder
 	auto block2 = builder
-	              .receive ()
-	              .previous (1)
-	              .source (2)
-	              .sign (key1.prv, key1.pub)
-	              .work (5)
-	              .build (ec);
+				  .receive ()
+				  .previous (1)
+				  .source (2)
+				  .sign (key1.prv, key1.pub)
+				  .work (5)
+				  .build (ec);
 
 	ASSERT_NO_ERROR (ec);
 	ASSERT_EQ (block1.hash (), block2->hash ());
@@ -711,10 +711,10 @@ TEST (block_builder, receive)
 	std::error_code ec;
 	nano::block_builder builder;
 	auto block = builder
-	             .receive ()
-	             .previous_hex ("59660153194CAC5DAC08509D87970BF86F6AEA943025E2A7ED7460930594950E")
-	             .source_hex ("7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135")
-	             .build (ec);
+				 .receive ()
+				 .previous_hex ("59660153194CAC5DAC08509D87970BF86F6AEA943025E2A7ED7460930594950E")
+				 .source_hex ("7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135")
+				 .build (ec);
 	ASSERT_EQ (block->hash ().to_string (), "6C004BF911D9CF2ED75CF6EC45E795122AD5D093FF5A83EDFBA43EC4A3EDC722");
 	ASSERT_EQ (block->source ().to_string (), "7B2B0A29C1B235FDF9B4DEF2984BB3573BD1A52D28246396FBB3E4C5FE662135");
 	ASSERT_TRUE (block->destination ().is_zero ());
diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp
index aa36272ea1..6173e7845f 100644
--- a/nano/core_test/block_store.cpp
+++ b/nano/core_test/block_store.cpp
@@ -1434,7 +1434,7 @@ TEST (mdb_block_store, upgrade_v16_v17)
 	nano::state_block block2 (nano::dev_genesis_key.pub, block1.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio - 1, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ()));
 	nano::state_block block3 (nano::dev_genesis_key.pub, block2.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio - 2, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block2.hash ()));
 
-	auto code = [&block1, &block2, &block3](auto confirmation_height, nano::block_hash const & expected_cemented_frontier) {
+	auto code = [&block1, &block2, &block3] (auto confirmation_height, nano::block_hash const & expected_cemented_frontier) {
 		auto path (nano::unique_path ());
 		nano::mdb_val value;
 		{
@@ -1854,7 +1854,7 @@ TEST (mdb_block_store, upgrade_backup)
 	fs::create_directory (dir);
 	auto path = dir / "data.ldb";
 	/** Returns 'dir' if backup file cannot be found */
-	auto get_backup_path = [&dir]() {
+	auto get_backup_path = [&dir] () {
 		for (fs::directory_iterator itr (dir); itr != fs::directory_iterator (); ++itr)
 		{
 			if (itr->path ().filename ().string ().find ("data_backup_") != std::string::npos)
diff --git a/nano/core_test/distributed_work.cpp b/nano/core_test/distributed_work.cpp
index 4ae0dbe3c8..91a054e903 100644
--- a/nano/core_test/distributed_work.cpp
+++ b/nano/core_test/distributed_work.cpp
@@ -20,7 +20,7 @@ TEST (distributed_work, no_peers)
 	nano::block_hash hash{ 1 };
 	boost::optional<uint64_t> work;
 	std::atomic<bool> done{ false };
-	auto callback = [&work, &done](boost::optional<uint64_t> work_a) {
+	auto callback = [&work, &done] (boost::optional<uint64_t> work_a) {
 		ASSERT_TRUE (work_a.is_initialized ());
 		work = work_a;
 		done = true;
@@ -54,7 +54,7 @@ TEST (distributed_work, no_peers_cancel)
 	auto & node = *system.add_node (node_config);
 	nano::block_hash hash{ 1 };
 	bool done{ false };
-	auto callback_to_cancel = [&done](boost::optional<uint64_t> work_a) {
+	auto callback_to_cancel = [&done] (boost::optional<uint64_t> work_a) {
 		ASSERT_FALSE (work_a.is_initialized ());
 		done = true;
 	};
@@ -83,7 +83,7 @@ TEST (distributed_work, no_peers_multi)
 	nano::block_hash hash{ 1 };
 	unsigned total{ 10 };
 	std::atomic<unsigned> count{ 0 };
-	auto callback = [&count](boost::optional<uint64_t> work_a) {
+	auto callback = [&count] (boost::optional<uint64_t> work_a) {
 		ASSERT_TRUE (work_a.is_initialized ());
 		++count;
 	};
@@ -127,7 +127,7 @@ TEST (distributed_work, peer)
 	nano::block_hash hash{ 1 };
 	boost::optional<uint64_t> work;
 	std::atomic<bool> done{ false };
-	auto callback = [&work, &done](boost::optional<uint64_t> work_a) {
+	auto callback = [&work, &done] (boost::optional<uint64_t> work_a) {
 		ASSERT_TRUE (work_a.is_initialized ());
 		work = work_a;
 		done = true;
@@ -153,7 +153,7 @@ TEST (distributed_work, peer_malicious)
 	nano::block_hash hash{ 1 };
 	boost::optional<uint64_t> work;
 	std::atomic<bool> done{ false };
-	auto callback = [&work, &done](boost::optional<uint64_t> work_a) {
+	auto callback = [&work, &done] (boost::optional<uint64_t> work_a) {
 		ASSERT_TRUE (work_a.is_initialized ());
 		work = work_a;
 		done = true;
@@ -193,7 +193,7 @@ TEST (distributed_work, peer_multi)
 	nano::block_hash hash{ 1 };
 	boost::optional<uint64_t> work;
 	std::atomic<bool> done{ false };
-	auto callback = [&work, &done](boost::optional<uint64_t> work_a) {
+	auto callback = [&work, &done] (boost::optional<uint64_t> work_a) {
 		ASSERT_TRUE (work_a.is_initialized ());
 		work = work_a;
 		done = true;
@@ -232,7 +232,7 @@ TEST (distributed_work, fail_resolve)
 	nano::block_hash hash{ 1 };
 	boost::optional<uint64_t> work;
 	std::atomic<bool> done{ false };
-	auto callback = [&work, &done](boost::optional<uint64_t> work_a) {
+	auto callback = [&work, &done] (boost::optional<uint64_t> work_a) {
 		ASSERT_TRUE (work_a.is_initialized ());
 		work = work_a;
 		done = true;
diff --git a/nano/core_test/election.cpp b/nano/core_test/election.cpp
index 58d0de0e78..8ac70cf4a0 100644
--- a/nano/core_test/election.cpp
+++ b/nano/core_test/election.cpp
@@ -28,25 +28,25 @@ TEST (election, quorum_minimum_flip_success)
 	nano::keypair key1;
 	nano::block_builder builder;
 	auto send1 = builder.state ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::genesis_hash)
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (node1.online_reps.delta ())
-	             .link (key1.pub)
-	             .work (0)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::genesis_hash)
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (node1.online_reps.delta ())
+				 .link (key1.pub)
+				 .work (0)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .build_shared ();
 	node1.work_generate_blocking (*send1);
 	nano::keypair key2;
 	auto send2 = builder.state ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::genesis_hash)
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (node1.online_reps.delta ())
-	             .link (key2.pub)
-	             .work (0)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::genesis_hash)
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (node1.online_reps.delta ())
+				 .link (key2.pub)
+				 .work (0)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .build_shared ();
 	node1.work_generate_blocking (*send2);
 	node1.process_active (send1);
 	node1.block_processor.flush ();
@@ -74,25 +74,25 @@ TEST (election, quorum_minimum_flip_fail)
 	nano::keypair key1;
 	nano::block_builder builder;
 	auto send1 = builder.state ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::genesis_hash)
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (node1.online_reps.delta () - 1)
-	             .link (key1.pub)
-	             .work (0)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::genesis_hash)
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (node1.online_reps.delta () - 1)
+				 .link (key1.pub)
+				 .work (0)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .build_shared ();
 	node1.work_generate_blocking (*send1);
 	nano::keypair key2;
 	auto send2 = builder.state ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::genesis_hash)
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (node1.online_reps.delta () - 1)
-	             .link (key2.pub)
-	             .work (0)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::genesis_hash)
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (node1.online_reps.delta () - 1)
+				 .link (key2.pub)
+				 .work (0)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .build_shared ();
 	node1.work_generate_blocking (*send2);
 	node1.process_active (send1);
 	node1.block_processor.flush ();
@@ -120,14 +120,14 @@ TEST (election, quorum_minimum_confirm_success)
 	nano::keypair key1;
 	nano::block_builder builder;
 	auto send1 = builder.state ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::genesis_hash)
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (node1.online_reps.delta ())
-	             .link (key1.pub)
-	             .work (0)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::genesis_hash)
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (node1.online_reps.delta ())
+				 .link (key1.pub)
+				 .work (0)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .build_shared ();
 	node1.work_generate_blocking (*send1);
 	node1.process_active (send1);
 	node1.block_processor.flush ();
@@ -152,14 +152,14 @@ TEST (election, quorum_minimum_confirm_fail)
 	nano::keypair key1;
 	nano::block_builder builder;
 	auto send1 = builder.state ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::genesis_hash)
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (node1.online_reps.delta () - 1)
-	             .link (key1.pub)
-	             .work (0)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::genesis_hash)
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (node1.online_reps.delta () - 1)
+				 .link (key1.pub)
+				 .work (0)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .build_shared ();
 	node1.work_generate_blocking (*send1);
 	node1.process_active (send1);
 	node1.block_processor.flush ();
@@ -187,34 +187,34 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks)
 	nano::keypair key1;
 	nano::block_builder builder;
 	auto send1 = builder.state ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::genesis_hash)
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (amount)
-	             .link (key1.pub)
-	             .work (0)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::genesis_hash)
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (amount)
+				 .link (key1.pub)
+				 .work (0)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .build_shared ();
 	node1.work_generate_blocking (*send1);
 	auto open1 = builder.state ()
-	             .account (key1.pub)
-	             .previous (0)
-	             .representative (key1.pub)
-	             .balance (nano::genesis_amount - amount)
-	             .link (send1->hash ())
-	             .work (0)
-	             .sign (key1.prv, key1.pub)
-	             .build_shared ();
+				 .account (key1.pub)
+				 .previous (0)
+				 .representative (key1.pub)
+				 .balance (nano::genesis_amount - amount)
+				 .link (send1->hash ())
+				 .work (0)
+				 .sign (key1.prv, key1.pub)
+				 .build_shared ();
 	nano::keypair key2;
 	auto send2 = builder.state ()
-	             .account (key1.pub)
-	             .previous (open1->hash ())
-	             .representative (key1.pub)
-	             .balance (3)
-	             .link (key2.pub)
-	             .work (0)
-	             .sign (key1.prv, key1.pub)
-	             .build_shared ();
+				 .account (key1.pub)
+				 .previous (open1->hash ())
+				 .representative (key1.pub)
+				 .balance (3)
+				 .link (key2.pub)
+				 .work (0)
+				 .sign (key1.prv, key1.pub)
+				 .build_shared ();
 	node1.work_generate_blocking (*open1);
 	node1.work_generate_blocking (*send2);
 	node1.process_active (send1);
diff --git a/nano/core_test/fakes/websocket_client.hpp b/nano/core_test/fakes/websocket_client.hpp
index 895b8bcd4b..9b05d9a885 100644
--- a/nano/core_test/fakes/websocket_client.hpp
+++ b/nano/core_test/fakes/websocket_client.hpp
@@ -17,7 +17,7 @@ class fake_websocket_client
 {
 public:
 	fake_websocket_client (unsigned port) :
-	socket (std::make_shared<boost::beast::websocket::stream<boost::asio::ip::tcp::socket>> (ioc))
+		socket (std::make_shared<boost::beast::websocket::stream<boost::asio::ip::tcp::socket>> (ioc))
 	{
 		std::string const host = "::1";
 		boost::asio::ip::tcp::resolver resolver{ ioc };
@@ -31,7 +31,7 @@ class fake_websocket_client
 	{
 		if (socket->is_open ())
 		{
-			socket->async_close (boost::beast::websocket::close_code::normal, [socket = this->socket](boost::beast::error_code const & ec) {
+			socket->async_close (boost::beast::websocket::close_code::normal, [socket = this->socket] (boost::beast::error_code const & ec) {
 				// A synchronous close usually hangs in tests when the server's io_context stops looping
 				// An async_close solves this problem
 			});
@@ -55,7 +55,7 @@ class fake_websocket_client
 		debug_assert (deadline > 0s);
 		boost::optional<std::string> result;
 		auto buffer (std::make_shared<boost::beast::flat_buffer> ());
-		socket->async_read (*buffer, [&result, &buffer, socket = this->socket](boost::beast::error_code const & ec, std::size_t const /*n*/) {
+		socket->async_read (*buffer, [&result, &buffer, socket = this->socket] (boost::beast::error_code const & ec, std::size_t const /*n*/) {
 			if (!ec)
 			{
 				std::ostringstream res;
diff --git a/nano/core_test/fakes/work_peer.hpp b/nano/core_test/fakes/work_peer.hpp
index 611c7659b5..aa874bec5e 100644
--- a/nano/core_test/fakes/work_peer.hpp
+++ b/nano/core_test/fakes/work_peer.hpp
@@ -35,14 +35,14 @@ class work_peer_connection : public std::enable_shared_from_this<work_peer_conne
 	const std::string generic_error = "Unable to parse JSON";
 
 public:
-	work_peer_connection (asio::io_context & ioc_a, work_peer_type const type_a, nano::work_version const version_a, nano::work_pool & pool_a, std::function<void(bool const)> on_generation_a, std::function<void()> on_cancel_a) :
-	socket (ioc_a),
-	type (type_a),
-	version (version_a),
-	work_pool (pool_a),
-	on_generation (on_generation_a),
-	on_cancel (on_cancel_a),
-	timer (ioc_a)
+	work_peer_connection (asio::io_context & ioc_a, work_peer_type const type_a, nano::work_version const version_a, nano::work_pool & pool_a, std::function<void (bool const)> on_generation_a, std::function<void ()> on_cancel_a) :
+		socket (ioc_a),
+		type (type_a),
+		version (version_a),
+		work_pool (pool_a),
+		on_generation (on_generation_a),
+		on_cancel (on_cancel_a),
+		timer (ioc_a)
 	{
 	}
 	void start ()
@@ -58,14 +58,14 @@ class work_peer_connection : public std::enable_shared_from_this<work_peer_conne
 	beast::flat_buffer buffer{ 8192 };
 	http::request<http::string_body> request;
 	http::response<http::dynamic_body> response;
-	std::function<void(bool const)> on_generation;
-	std::function<void()> on_cancel;
+	std::function<void (bool const)> on_generation;
+	std::function<void ()> on_cancel;
 	asio::deadline_timer timer;
 
 	void read_request ()
 	{
 		auto this_l = shared_from_this ();
-		http::async_read (socket, buffer, request, [this_l](beast::error_code ec, std::size_t const /*size_a*/) {
+		http::async_read (socket, buffer, request, [this_l] (beast::error_code ec, std::size_t const /*size_a*/) {
 			if (!ec)
 			{
 				this_l->process_request ();
@@ -110,7 +110,7 @@ class work_peer_connection : public std::enable_shared_from_this<work_peer_conne
 	{
 		auto this_l = shared_from_this ();
 		response.content_length (response.body ().size ());
-		http::async_write (socket, response, [this_l](beast::error_code ec, std::size_t /*size_a*/) {
+		http::async_write (socket, response, [this_l] (beast::error_code ec, std::size_t /*size_a*/) {
 			this_l->socket.shutdown (tcp::socket::shutdown_send, ec);
 			this_l->socket.close ();
 		});
@@ -143,7 +143,7 @@ class work_peer_connection : public std::enable_shared_from_this<work_peer_conne
 			auto hash = hash_a;
 			auto request_difficulty = nano::work_threshold_base (version);
 			auto this_l (shared_from_this ());
-			work_pool.generate (version, hash, request_difficulty, [this_l, hash](boost::optional<uint64_t> work_a) {
+			work_pool.generate (version, hash, request_difficulty, [this_l, hash] (boost::optional<uint64_t> work_a) {
 				auto result = work_a.value_or (0);
 				auto result_difficulty (nano::work_difficulty (this_l->version, hash, result));
 				static nano::network_params params;
@@ -157,7 +157,7 @@ class work_peer_connection : public std::enable_shared_from_this<work_peer_conne
 				beast::ostream (this_l->response.body ()) << ostream.str ();
 				// Delay response by 500ms as a slow peer, immediate async call for a good peer
 				this_l->timer.expires_from_now (boost::posix_time::milliseconds (this_l->type == work_peer_type::slow ? 500 : 0));
-				this_l->timer.async_wait ([this_l, result](const boost::system::error_code & ec) {
+				this_l->timer.async_wait ([this_l, result] (const boost::system::error_code & ec) {
 					if (this_l->on_generation)
 					{
 						this_l->on_generation (result != 0);
@@ -200,12 +200,12 @@ class fake_work_peer : public std::enable_shared_from_this<fake_work_peer>
 public:
 	fake_work_peer () = delete;
 	fake_work_peer (nano::work_pool & pool_a, asio::io_context & ioc_a, unsigned short port_a, work_peer_type const type_a, nano::work_version const version_a = nano::work_version::work_1) :
-	pool (pool_a),
-	endpoint (tcp::v4 (), port_a),
-	ioc (ioc_a),
-	acceptor (ioc_a, endpoint),
-	type (type_a),
-	version (version_a)
+		pool (pool_a),
+		endpoint (tcp::v4 (), port_a),
+		ioc (ioc_a),
+		acceptor (ioc_a, endpoint),
+		type (type_a),
+		version (version_a)
 	{
 	}
 	void start ()
@@ -226,7 +226,7 @@ class fake_work_peer : public std::enable_shared_from_this<fake_work_peer>
 		std::weak_ptr<fake_work_peer> this_w (shared_from_this ());
 		auto connection (std::make_shared<work_peer_connection> (
 		ioc, type, version, pool,
-		[this_w](bool const good_generation) {
+		[this_w] (bool const good_generation) {
 			if (auto this_l = this_w.lock ())
 			{
 				if (good_generation)
@@ -239,13 +239,13 @@ class fake_work_peer : public std::enable_shared_from_this<fake_work_peer>
 				}
 			};
 		},
-		[this_w]() {
+		[this_w] () {
 			if (auto this_l = this_w.lock ())
 			{
 				++this_l->cancels;
 			}
 		}));
-		acceptor.async_accept (connection->socket, [connection, this_w](beast::error_code ec) {
+		acceptor.async_accept (connection->socket, [connection, this_w] (beast::error_code ec) {
 			if (!ec)
 			{
 				if (auto this_l = this_w.lock ())
diff --git a/nano/core_test/frontiers_confirmation.cpp b/nano/core_test/frontiers_confirmation.cpp
index 18b57f45b8..120a71bc8d 100644
--- a/nano/core_test/frontiers_confirmation.cpp
+++ b/nano/core_test/frontiers_confirmation.cpp
@@ -69,8 +69,8 @@ TEST (frontiers_confirmation, prioritize_frontiers)
 
 	auto transaction = node->store.tx_begin_read ();
 	constexpr auto num_accounts = 5;
-	auto priority_orders_match = [](auto const & cementable_frontiers, auto const & desired_order) {
-		return std::equal (desired_order.begin (), desired_order.end (), cementable_frontiers.template get<1> ().begin (), cementable_frontiers.template get<1> ().end (), [](nano::account const & account, nano::cementable_account const & cementable_account) {
+	auto priority_orders_match = [] (auto const & cementable_frontiers, auto const & desired_order) {
+		return std::equal (desired_order.begin (), desired_order.end (), cementable_frontiers.template get<1> ().begin (), cementable_frontiers.template get<1> ().end (), [] (nano::account const & account, nano::cementable_account const & cementable_account) {
 			return (account == cementable_account.account);
 		});
 	};
diff --git a/nano/core_test/ipc.cpp b/nano/core_test/ipc.cpp
index 5092588d10..012a2e5632 100644
--- a/nano/core_test/ipc.cpp
+++ b/nano/core_test/ipc.cpp
@@ -29,17 +29,17 @@ TEST (ipc, asynchronous)
 	auto req (nano::ipc::prepare_request (nano::ipc::payload_encoding::json_v1, std::string (R"({"action": "block_count"})")));
 	auto res (std::make_shared<std::vector<uint8_t>> ());
 	std::atomic<bool> call_completed{ false };
-	client.async_connect ("::1", 24077, [&client, &req, &res, &call_completed](nano::error err) {
-		client.async_write (req, [&client, &req, &res, &call_completed](nano::error err_a, size_t size_a) {
+	client.async_connect ("::1", 24077, [&client, &req, &res, &call_completed] (nano::error err) {
+		client.async_write (req, [&client, &req, &res, &call_completed] (nano::error err_a, size_t size_a) {
 			ASSERT_NO_ERROR (static_cast<std::error_code> (err_a));
 			ASSERT_EQ (size_a, req.size ());
 			// Read length
-			client.async_read (res, sizeof (uint32_t), [&client, &res, &call_completed](nano::error err_read_a, size_t size_read_a) {
+			client.async_read (res, sizeof (uint32_t), [&client, &res, &call_completed] (nano::error err_read_a, size_t size_read_a) {
 				ASSERT_NO_ERROR (static_cast<std::error_code> (err_read_a));
 				ASSERT_EQ (size_read_a, sizeof (uint32_t));
 				uint32_t payload_size_l = boost::endian::big_to_native (*reinterpret_cast<uint32_t *> (res->data ()));
 				// Read json payload
-				client.async_read (res, payload_size_l, [&res, &call_completed](nano::error err_read_a, size_t size_read_a) {
+				client.async_read (res, payload_size_l, [&res, &call_completed] (nano::error err_read_a, size_t size_read_a) {
 					std::string payload (res->begin (), res->end ());
 					std::stringstream ss;
 					ss << payload;
@@ -68,7 +68,7 @@ TEST (ipc, synchronous)
 
 	// Start blocking IPC client in a separate thread
 	std::atomic<bool> call_completed{ false };
-	std::thread client_thread ([&client, &call_completed]() {
+	std::thread client_thread ([&client, &call_completed] () {
 		client.connect ("::1", 24077);
 		std::string response (nano::ipc::request (nano::ipc::payload_encoding::json_v1, client, std::string (R"({"action": "block_count"})")));
 		std::stringstream ss;
diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp
index 623cb8a785..6336db8793 100644
--- a/nano/core_test/ledger.cpp
+++ b/nano/core_test/ledger.cpp
@@ -849,14 +849,14 @@ TEST (votes, add_existing)
 	nano::keypair key1;
 	nano::block_builder builder;
 	std::shared_ptr<nano::block> send1 = builder.state ()
-	                                     .account (nano::dev_genesis_key.pub)
-	                                     .previous (nano::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)
-	                                     .work (0)
-	                                     .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                                     .build ();
+										 .account (nano::dev_genesis_key.pub)
+										 .previous (nano::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)
+										 .work (0)
+										 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+										 .build ();
 	node1.work_generate_blocking (*send1);
 	ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code);
 	node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ());
@@ -869,14 +869,14 @@ TEST (votes, add_existing)
 	ASSERT_EQ (1, election1->last_votes[nano::dev_genesis_key.pub].timestamp);
 	nano::keypair key2;
 	std::shared_ptr<nano::block> send2 = builder.state ()
-	                                     .account (nano::dev_genesis_key.pub)
-	                                     .previous (nano::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)
-	                                     .work (0)
-	                                     .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                                     .build ();
+										 .account (nano::dev_genesis_key.pub)
+										 .previous (nano::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)
+										 .work (0)
+										 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+										 .build ();
 	node1.work_generate_blocking (*send2);
 	auto vote2 (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 2, send2));
 	// Pretend we've waited the timeout
@@ -2649,14 +2649,14 @@ TEST (ledger, epoch_open_pending)
 	nano::work_pool pool (std::numeric_limits<unsigned>::max ());
 	nano::keypair key1;
 	auto epoch_open = builder.state ()
-	                  .account (key1.pub)
-	                  .previous (0)
-	                  .representative (0)
-	                  .balance (0)
-	                  .link (node1.ledger.epoch_link (nano::epoch::epoch_1))
-	                  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                  .work (*pool.generate (key1.pub))
-	                  .build_shared ();
+					  .account (key1.pub)
+					  .previous (0)
+					  .representative (0)
+					  .balance (0)
+					  .link (node1.ledger.epoch_link (nano::epoch::epoch_1))
+					  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					  .work (*pool.generate (key1.pub))
+					  .build_shared ();
 	auto process_result (node1.ledger.process (node1.store.tx_begin_write (), *epoch_open));
 	ASSERT_EQ (nano::process_result::gap_epoch_open_pending, process_result.code);
 	ASSERT_EQ (nano::signature_verification::valid_epoch, process_result.verified);
@@ -2670,14 +2670,14 @@ TEST (ledger, epoch_open_pending)
 	ASSERT_EQ (blocks[0].verified, nano::signature_verification::valid_epoch);
 	// New block to process epoch open
 	auto send1 = builder.state ()
-	             .account (nano::genesis_account)
-	             .previous (nano::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))
-	             .build_shared ();
+				 .account (nano::genesis_account)
+				 .previous (nano::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))
+				 .build_shared ();
 	node1.block_processor.add (send1);
 	node1.block_processor.flush ();
 	ASSERT_TRUE (node1.ledger.block_exists (epoch_open->hash ()));
@@ -2698,24 +2698,24 @@ TEST (ledger, block_hash_account_conflict)
 	 * in the ledger and not an account
 	 */
 	auto send1 = builder.state ()
-	             .account (nano::genesis_account)
-	             .previous (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 (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::genesis_account)
+				 .previous (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 (genesis.hash ()))
+				 .build_shared ();
 
 	auto receive1 = builder.state ()
-	                .account (key1.pub)
-	                .previous (0)
-	                .representative (nano::genesis_account)
-	                .balance (100)
-	                .link (send1->hash ())
-	                .sign (key1.prv, key1.pub)
-	                .work (*pool.generate (key1.pub))
-	                .build_shared ();
+					.account (key1.pub)
+					.previous (0)
+					.representative (nano::genesis_account)
+					.balance (100)
+					.link (send1->hash ())
+					.sign (key1.prv, key1.pub)
+					.work (*pool.generate (key1.pub))
+					.build_shared ();
 
 	/*
 	 * Note that the below link is a block hash when this is intended
@@ -2724,28 +2724,28 @@ TEST (ledger, block_hash_account_conflict)
 	 * for arbitrary accounts.
 	 */
 	auto send2 = builder.state ()
-	             .account (key1.pub)
-	             .previous (receive1->hash ())
-	             .representative (nano::genesis_account)
-	             .balance (90)
-	             .link (receive1->hash ())
-	             .sign (key1.prv, key1.pub)
-	             .work (*pool.generate (receive1->hash ()))
-	             .build_shared ();
+				 .account (key1.pub)
+				 .previous (receive1->hash ())
+				 .representative (nano::genesis_account)
+				 .balance (90)
+				 .link (receive1->hash ())
+				 .sign (key1.prv, key1.pub)
+				 .work (*pool.generate (receive1->hash ()))
+				 .build_shared ();
 
 	/*
 	 * Generate an epoch open for the account with the same value as the block hash
 	 */
 	auto receive1_hash = receive1->hash ();
 	auto open_epoch1 = builder.state ()
-	                   .account (reinterpret_cast<nano::account const &> (receive1_hash))
-	                   .previous (0)
-	                   .representative (0)
-	                   .balance (0)
-	                   .link (node1.ledger.epoch_link (nano::epoch::epoch_1))
-	                   .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                   .work (*pool.generate (receive1->hash ()))
-	                   .build_shared ();
+					   .account (reinterpret_cast<nano::account const &> (receive1_hash))
+					   .previous (0)
+					   .representative (0)
+					   .balance (0)
+					   .link (node1.ledger.epoch_link (nano::epoch::epoch_1))
+					   .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					   .work (*pool.generate (receive1->hash ()))
+					   .build_shared ();
 
 	node1.work_generate_blocking (*send1);
 	node1.work_generate_blocking (*receive1);
@@ -3052,27 +3052,27 @@ TEST (ledger, zero_rep)
 	nano::genesis genesis;
 	nano::block_builder builder;
 	auto block1 = builder.state ()
-	              .account (nano::dev_genesis_key.pub)
-	              .previous (genesis.hash ())
-	              .representative (0)
-	              .balance (nano::genesis_amount)
-	              .link (0)
-	              .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	              .work (*system.work.generate (genesis.hash ()))
-	              .build ();
+				  .account (nano::dev_genesis_key.pub)
+				  .previous (genesis.hash ())
+				  .representative (0)
+				  .balance (nano::genesis_amount)
+				  .link (0)
+				  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				  .work (*system.work.generate (genesis.hash ()))
+				  .build ();
 	auto transaction (node1.store.tx_begin_write ());
 	ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *block1).code);
 	ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (nano::dev_genesis_key.pub));
 	ASSERT_EQ (nano::genesis_amount, node1.ledger.cache.rep_weights.representation_get (0));
 	auto block2 = builder.state ()
-	              .account (nano::dev_genesis_key.pub)
-	              .previous (block1->hash ())
-	              .representative (nano::dev_genesis_key.pub)
-	              .balance (nano::genesis_amount)
-	              .link (0)
-	              .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	              .work (*system.work.generate (block1->hash ()))
-	              .build ();
+				  .account (nano::dev_genesis_key.pub)
+				  .previous (block1->hash ())
+				  .representative (nano::dev_genesis_key.pub)
+				  .balance (nano::genesis_amount)
+				  .link (0)
+				  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				  .work (*system.work.generate (block1->hash ()))
+				  .build ();
 	ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *block2).code);
 	ASSERT_EQ (nano::genesis_amount, node1.ledger.cache.rep_weights.representation_get (nano::dev_genesis_key.pub));
 	ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (0));
@@ -3108,59 +3108,59 @@ TEST (ledger, work_validation)
 	std::error_code ec;
 
 	auto send = *builder.send ()
-	             .previous (nano::genesis_hash)
-	             .destination (gen.pub)
-	             .balance (nano::genesis_amount - 1)
-	             .sign (gen.prv, gen.pub)
-	             .work (0)
-	             .build (ec);
+				 .previous (nano::genesis_hash)
+				 .destination (gen.pub)
+				 .balance (nano::genesis_amount - 1)
+				 .sign (gen.prv, gen.pub)
+				 .work (0)
+				 .build (ec);
 	ASSERT_FALSE (ec);
 
 	auto receive = *builder.receive ()
-	                .previous (send.hash ())
-	                .source (send.hash ())
-	                .sign (gen.prv, gen.pub)
-	                .work (0)
-	                .build (ec);
+					.previous (send.hash ())
+					.source (send.hash ())
+					.sign (gen.prv, gen.pub)
+					.work (0)
+					.build (ec);
 	ASSERT_FALSE (ec);
 
 	auto change = *builder.change ()
-	               .previous (receive.hash ())
-	               .representative (key.pub)
-	               .sign (gen.prv, gen.pub)
-	               .work (0)
-	               .build (ec);
+				   .previous (receive.hash ())
+				   .representative (key.pub)
+				   .sign (gen.prv, gen.pub)
+				   .work (0)
+				   .build (ec);
 	ASSERT_FALSE (ec);
 
 	auto state = *builder.state ()
-	              .account (gen.pub)
-	              .previous (change.hash ())
-	              .representative (gen.pub)
-	              .balance (nano::genesis_amount - 1)
-	              .link (key.pub)
-	              .sign (gen.prv, gen.pub)
-	              .work (0)
-	              .build (ec);
+				  .account (gen.pub)
+				  .previous (change.hash ())
+				  .representative (gen.pub)
+				  .balance (nano::genesis_amount - 1)
+				  .link (key.pub)
+				  .sign (gen.prv, gen.pub)
+				  .work (0)
+				  .build (ec);
 	ASSERT_FALSE (ec);
 
 	auto open = *builder.open ()
-	             .account (key.pub)
-	             .source (state.hash ())
-	             .representative (key.pub)
-	             .sign (key.prv, key.pub)
-	             .work (0)
-	             .build (ec);
+				 .account (key.pub)
+				 .source (state.hash ())
+				 .representative (key.pub)
+				 .sign (key.prv, key.pub)
+				 .work (0)
+				 .build (ec);
 	ASSERT_FALSE (ec);
 
 	auto epoch = *builder.state ()
-	              .account (key.pub)
-	              .previous (open.hash ())
-	              .balance (1)
-	              .representative (key.pub)
-	              .link (ledger.epoch_link (nano::epoch::epoch_1))
-	              .sign (gen.prv, gen.pub)
-	              .work (0)
-	              .build (ec);
+				  .account (key.pub)
+				  .previous (open.hash ())
+				  .balance (1)
+				  .representative (key.pub)
+				  .link (ledger.epoch_link (nano::epoch::epoch_1))
+				  .sign (gen.prv, gen.pub)
+				  .work (0)
+				  .build (ec);
 	ASSERT_FALSE (ec);
 
 	process_block (send, {});
@@ -3186,36 +3186,36 @@ TEST (ledger, dependents_confirmed)
 	nano::work_pool pool (std::numeric_limits<unsigned>::max ());
 	nano::keypair key1;
 	auto send1 = builder.state ()
-	             .account (nano::genesis_account)
-	             .previous (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 (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::genesis_account)
+				 .previous (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 (genesis.hash ()))
+				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code);
 	ASSERT_TRUE (ledger.dependents_confirmed (transaction, *send1));
 	auto send2 = builder.state ()
-	             .account (nano::genesis_account)
-	             .previous (send1->hash ())
-	             .representative (nano::genesis_account)
-	             .balance (nano::genesis_amount - 200)
-	             .link (key1.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*pool.generate (send1->hash ()))
-	             .build_shared ();
+				 .account (nano::genesis_account)
+				 .previous (send1->hash ())
+				 .representative (nano::genesis_account)
+				 .balance (nano::genesis_amount - 200)
+				 .link (key1.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*pool.generate (send1->hash ()))
+				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code);
 	ASSERT_FALSE (ledger.dependents_confirmed (transaction, *send2));
 	auto receive1 = builder.state ()
-	                .account (key1.pub)
-	                .previous (0)
-	                .representative (nano::genesis_account)
-	                .balance (100)
-	                .link (send1->hash ())
-	                .sign (key1.prv, key1.pub)
-	                .work (*pool.generate (key1.pub))
-	                .build_shared ();
+					.account (key1.pub)
+					.previous (0)
+					.representative (nano::genesis_account)
+					.balance (100)
+					.link (send1->hash ())
+					.sign (key1.prv, key1.pub)
+					.work (*pool.generate (key1.pub))
+					.build_shared ();
 	ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code);
 	ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive1));
 	nano::confirmation_height_info height;
@@ -3224,14 +3224,14 @@ TEST (ledger, dependents_confirmed)
 	ledger.store.confirmation_height_put (transaction, nano::genesis_account, height);
 	ASSERT_TRUE (ledger.dependents_confirmed (transaction, *receive1));
 	auto receive2 = builder.state ()
-	                .account (key1.pub)
-	                .previous (receive1->hash ())
-	                .representative (nano::genesis_account)
-	                .balance (200)
-	                .link (send2->hash ())
-	                .sign (key1.prv, key1.pub)
-	                .work (*pool.generate (receive1->hash ()))
-	                .build_shared ();
+					.account (key1.pub)
+					.previous (receive1->hash ())
+					.representative (nano::genesis_account)
+					.balance (200)
+					.link (send2->hash ())
+					.sign (key1.prv, key1.pub)
+					.work (*pool.generate (receive1->hash ()))
+					.build_shared ();
 	ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive2).code);
 	ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive2));
 	ASSERT_TRUE (ledger.store.confirmation_height_get (transaction, key1.pub, height));
@@ -3259,14 +3259,14 @@ TEST (ledger, block_confirmed)
 	nano::work_pool pool (std::numeric_limits<unsigned>::max ());
 	nano::keypair key1;
 	auto send1 = builder.state ()
-	             .account (nano::genesis_account)
-	             .previous (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 (genesis.hash ()))
-	             .build ();
+				 .account (nano::genesis_account)
+				 .previous (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 (genesis.hash ()))
+				 .build ();
 	// Must be safe against non-existing blocks
 	ASSERT_FALSE (ledger.block_confirmed (transaction, send1->hash ()));
 	ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code);
@@ -3312,23 +3312,23 @@ TEST (ledger, cache)
 		nano::keypair key;
 		auto const latest = ledger.latest (store->tx_begin_read (), nano::genesis_account);
 		auto send = builder.state ()
-		            .account (nano::genesis_account)
-		            .previous (latest)
-		            .representative (nano::genesis_account)
-		            .balance (nano::genesis_amount - (i + 1))
-		            .link (key.pub)
-		            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		            .work (*pool.generate (latest))
-		            .build ();
+					.account (nano::genesis_account)
+					.previous (latest)
+					.representative (nano::genesis_account)
+					.balance (nano::genesis_amount - (i + 1))
+					.link (key.pub)
+					.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					.work (*pool.generate (latest))
+					.build ();
 		auto open = builder.state ()
-		            .account (key.pub)
-		            .previous (0)
-		            .representative (key.pub)
-		            .balance (1)
-		            .link (send->hash ())
-		            .sign (key.prv, key.pub)
-		            .work (*pool.generate (key.pub))
-		            .build ();
+					.account (key.pub)
+					.previous (0)
+					.representative (key.pub)
+					.balance (1)
+					.link (send->hash ())
+					.sign (key.prv, key.pub)
+					.work (*pool.generate (key.pub))
+					.build ();
 		{
 			auto transaction (store->tx_begin_write ());
 			ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code);
@@ -3790,14 +3790,14 @@ TEST (ledger, migrate_lmdb_to_rocksdb)
 	nano::work_pool pool (std::numeric_limits<unsigned>::max ());
 
 	auto send = nano::state_block_builder ()
-	            .account (nano::dev_genesis_key.pub)
-	            .previous (nano::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))
-	            .build_shared ();
+				.account (nano::dev_genesis_key.pub)
+				.previous (nano::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))
+				.build_shared ();
 
 	nano::endpoint_key endpoint_key (address.to_bytes (), port);
 	auto version = 99;
@@ -3877,14 +3877,14 @@ TEST (ledger, unconfirmed_frontiers)
 	nano::keypair key;
 	auto const latest = ledger.latest (store->tx_begin_read (), nano::genesis_account);
 	auto send = builder.make_block ()
-	            .account (nano::genesis_account)
-	            .previous (latest)
-	            .representative (nano::genesis_account)
-	            .balance (nano::genesis_amount - 100)
-	            .link (key.pub)
-	            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	            .work (*pool.generate (latest))
-	            .build ();
+				.account (nano::genesis_account)
+				.previous (latest)
+				.representative (nano::genesis_account)
+				.balance (nano::genesis_amount - 100)
+				.link (key.pub)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*pool.generate (latest))
+				.build ();
 
 	ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *send).code);
 
diff --git a/nano/core_test/locks.cpp b/nano/core_test/locks.cpp
index 8f680312b6..67591019d3 100644
--- a/nano/core_test/locks.cpp
+++ b/nano/core_test/locks.cpp
@@ -156,7 +156,7 @@ TEST (locks, condition_variable_wait_until)
 
 	nano::condition_variable cv;
 	nano::mutex mutex;
-	auto impl = [&](auto time_to_sleep) {
+	auto impl = [&] (auto time_to_sleep) {
 		std::atomic<bool> notified{ false };
 		std::atomic<bool> finished{ false };
 		nano::unique_lock<nano::mutex> lk (mutex);
diff --git a/nano/core_test/memory_pool.cpp b/nano/core_test/memory_pool.cpp
index a3412f7f3e..66383e502b 100644
--- a/nano/core_test/memory_pool.cpp
+++ b/nano/core_test/memory_pool.cpp
@@ -17,7 +17,7 @@ class record_allocations_new_delete_allocator
 	using value_type = T;
 
 	explicit record_allocations_new_delete_allocator (std::vector<size_t> * allocated) :
-	allocated (allocated)
+		allocated (allocated)
 	{
 	}
 
diff --git a/nano/core_test/network_filter.cpp b/nano/core_test/network_filter.cpp
index 87b26758e2..5770d83ff4 100644
--- a/nano/core_test/network_filter.cpp
+++ b/nano/core_test/network_filter.cpp
@@ -10,7 +10,7 @@ TEST (network_filter, unit)
 {
 	nano::genesis genesis;
 	nano::network_filter filter (1);
-	auto one_block = [&filter](std::shared_ptr<nano::block> const & block_a, bool expect_duplicate_a) {
+	auto one_block = [&filter] (std::shared_ptr<nano::block> const & block_a, bool expect_duplicate_a) {
 		nano::publish message (block_a);
 		auto bytes (message.to_bytes ());
 		nano::bufferstream stream (bytes->data (), bytes->size ());
diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp
index c7e9195f0b..5701286c63 100644
--- a/nano/core_test/node.cpp
+++ b/nano/core_test/node.cpp
@@ -189,26 +189,26 @@ TEST (node, send_out_of_order)
 	nano::genesis genesis;
 	nano::send_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .previous (genesis.hash ())
-	             .destination (key2.pub)
-	             .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key2.pub)
+				 .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .previous (send1->hash ())
-	             .destination (key2.pub)
-	             .balance (std::numeric_limits<nano::uint128_t>::max () - 2 * node1.config.receive_minimum.number ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send1->hash ()))
-	             .build_shared ();
+				 .previous (send1->hash ())
+				 .destination (key2.pub)
+				 .balance (std::numeric_limits<nano::uint128_t>::max () - 2 * node1.config.receive_minimum.number ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send1->hash ()))
+				 .build_shared ();
 	auto send3 = builder.make_block ()
-	             .previous (send2->hash ())
-	             .destination (key2.pub)
-	             .balance (std::numeric_limits<nano::uint128_t>::max () - 3 * node1.config.receive_minimum.number ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send2->hash ()))
-	             .build_shared ();
+				 .previous (send2->hash ())
+				 .destination (key2.pub)
+				 .balance (std::numeric_limits<nano::uint128_t>::max () - 3 * node1.config.receive_minimum.number ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send2->hash ()))
+				 .build_shared ();
 	node1.process_active (send3);
 	node1.process_active (send2);
 	node1.process_active (send1);
@@ -225,12 +225,12 @@ TEST (node, quick_confirm)
 	system.wallet (0)->insert_adhoc (key.prv);
 	system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
 	auto send = nano::send_block_builder ()
-	            .previous (previous)
-	            .destination (key.pub)
-	            .balance (node1.online_reps.delta () + 1)
-	            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	            .work (*system.work.generate (previous))
-	            .build_shared ();
+				.previous (previous)
+				.destination (key.pub)
+				.balance (node1.online_reps.delta () + 1)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*system.work.generate (previous))
+				.build_shared ();
 	node1.process_active (send);
 	ASSERT_TIMELY (10s, !node1.balance (key.pub).is_zero ());
 	ASSERT_EQ (node1.balance (nano::dev_genesis_key.pub), node1.online_reps.delta () + 1);
@@ -245,12 +245,12 @@ TEST (node, node_receive_quorum)
 	nano::block_hash previous (node1.latest (nano::dev_genesis_key.pub));
 	system.wallet (0)->insert_adhoc (key.prv);
 	auto send = nano::send_block_builder ()
-	            .previous (previous)
-	            .destination (key.pub)
-	            .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	            .work (*system.work.generate (previous))
-	            .build_shared ();
+				.previous (previous)
+				.destination (key.pub)
+				.balance (nano::genesis_amount - nano::Gxrb_ratio)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*system.work.generate (previous))
+				.build_shared ();
 	node1.process_active (send);
 	ASSERT_TIMELY (10s, node1.ledger.block_exists (send->hash ()));
 	ASSERT_TIMELY (10s, node1.active.election (nano::qualified_root (previous, previous)) != nullptr);
@@ -355,12 +355,12 @@ TEST (node, receive_gap)
 	auto & node1 (*system.nodes[0]);
 	ASSERT_EQ (0, node1.gap_cache.size ());
 	auto block = nano::send_block_builder ()
-	             .previous (5)
-	             .destination (1)
-	             .balance (2)
-	             .sign (nano::keypair ().prv, 4)
-	             .work (0)
-	             .build_shared ();
+				 .previous (5)
+				 .destination (1)
+				 .balance (2)
+				 .sign (nano::keypair ().prv, 4)
+				 .work (0)
+				 .build_shared ();
 	node1.work_generate_blocking (*block);
 	nano::publish message (block);
 	node1.network.process_message (message, node1.network.udp_channels.create (node1.network.endpoint ()));
@@ -575,12 +575,12 @@ TEST (node, confirm_locked)
 	auto transaction (system.wallet (0)->wallets.tx_begin_read ());
 	system.wallet (0)->enter_password (transaction, "1");
 	auto block = nano::send_block_builder ()
-	             .previous (0)
-	             .destination (0)
-	             .balance (0)
-	             .sign (nano::keypair ().prv, 0)
-	             .work (0)
-	             .build_shared ();
+				 .previous (0)
+				 .destination (0)
+				 .balance (0)
+				 .sign (nano::keypair ().prv, 0)
+				 .work (0)
+				 .build_shared ();
 	system.nodes[0]->network.flood_block (block);
 }
 
@@ -856,7 +856,7 @@ class json_initial_value_test final
 {
 public:
 	explicit json_initial_value_test (std::string const & text_a) :
-	text (text_a)
+		text (text_a)
 	{
 	}
 	nano::error serialize_json (nano::jsonconfig & json)
@@ -1061,21 +1061,21 @@ TEST (node, fork_publish)
 		nano::genesis genesis;
 		nano::send_block_builder builder;
 		auto send1 = builder.make_block ()
-		             .previous (genesis.hash ())
-		             .destination (key1.pub)
-		             .balance (nano::genesis_amount - 100)
-		             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		             .work (0)
-		             .build_shared ();
+					 .previous (genesis.hash ())
+					 .destination (key1.pub)
+					 .balance (nano::genesis_amount - 100)
+					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					 .work (0)
+					 .build_shared ();
 		node1.work_generate_blocking (*send1);
 		nano::keypair key2;
 		auto send2 = builder.make_block ()
-		             .previous (genesis.hash ())
-		             .destination (key2.pub)
-		             .balance (nano::genesis_amount - 100)
-		             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		             .work (0)
-		             .build_shared ();
+					 .previous (genesis.hash ())
+					 .destination (key2.pub)
+					 .balance (nano::genesis_amount - 100)
+					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					 .work (0)
+					 .build_shared ();
 		node1.work_generate_blocking (*send2);
 		node1.process_active (send1);
 		node1.block_processor.flush ();
@@ -1107,19 +1107,19 @@ TEST (node, fork_publish_inactive)
 	nano::keypair key2;
 	nano::send_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .previous (genesis.hash ())
-	             .destination (key1.pub)
-	             .balance (nano::genesis_amount - 100)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key1.pub)
+				 .balance (nano::genesis_amount - 100)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .previous (genesis.hash ())
-	             .destination (key2.pub)
-	             .balance (nano::genesis_amount - 100)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (send1->block_work ())
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key2.pub)
+				 .balance (nano::genesis_amount - 100)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (send1->block_work ())
+				 .build_shared ();
 	auto & node = *system.nodes[0];
 	node.process_active (send1);
 	ASSERT_TIMELY (3s, nullptr != node.block (send1->hash ()));
@@ -1145,19 +1145,19 @@ TEST (node, fork_keep)
 	nano::send_block_builder builder;
 	// send1 and send2 fork to different accounts
 	auto send1 = builder.make_block ()
-	             .previous (genesis.hash ())
-	             .destination (key1.pub)
-	             .balance (nano::genesis_amount - 100)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key1.pub)
+				 .balance (nano::genesis_amount - 100)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .previous (genesis.hash ())
-	             .destination (key2.pub)
-	             .balance (nano::genesis_amount - 100)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key2.pub)
+				 .balance (nano::genesis_amount - 100)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	node1.process_active (send1);
 	node1.block_processor.flush ();
 	node1.scheduler.flush ();
@@ -1198,21 +1198,21 @@ TEST (node, fork_flip)
 	nano::genesis genesis;
 	nano::send_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .previous (genesis.hash ())
-	             .destination (key1.pub)
-	             .balance (nano::genesis_amount - 100)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key1.pub)
+				 .balance (nano::genesis_amount - 100)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	nano::publish publish1 (send1);
 	nano::keypair key2;
 	auto send2 = builder.make_block ()
-	             .previous (genesis.hash ())
-	             .destination (key2.pub)
-	             .balance (nano::genesis_amount - 100)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key2.pub)
+				 .balance (nano::genesis_amount - 100)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	nano::publish publish2 (send2);
 	auto channel1 (node1.network.udp_channels.create (node1.network.endpoint ()));
 	node1.network.process_message (publish1, channel1);
@@ -1266,29 +1266,29 @@ TEST (node, fork_multi_flip)
 		nano::genesis genesis;
 		nano::send_block_builder builder;
 		auto send1 = builder.make_block ()
-		             .previous (genesis.hash ())
-		             .destination (key1.pub)
-		             .balance (nano::genesis_amount - 100)
-		             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		             .work (*system.work.generate (genesis.hash ()))
-		             .build_shared ();
+					 .previous (genesis.hash ())
+					 .destination (key1.pub)
+					 .balance (nano::genesis_amount - 100)
+					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					 .work (*system.work.generate (genesis.hash ()))
+					 .build_shared ();
 		nano::publish publish1 (send1);
 		nano::keypair key2;
 		auto send2 = builder.make_block ()
-		             .previous (genesis.hash ())
-		             .destination (key2.pub)
-		             .balance (nano::genesis_amount - 100)
-		             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		             .work (*system.work.generate (genesis.hash ()))
-		             .build_shared ();
+					 .previous (genesis.hash ())
+					 .destination (key2.pub)
+					 .balance (nano::genesis_amount - 100)
+					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					 .work (*system.work.generate (genesis.hash ()))
+					 .build_shared ();
 		nano::publish publish2 (send2);
 		auto send3 = builder.make_block ()
-		             .previous (publish2.block->hash ())
-		             .destination (key2.pub)
-		             .balance (nano::genesis_amount - 100)
-		             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		             .work (*system.work.generate (publish2.block->hash ()))
-		             .build_shared ();
+					 .previous (publish2.block->hash ())
+					 .destination (key2.pub)
+					 .balance (nano::genesis_amount - 100)
+					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					 .work (*system.work.generate (publish2.block->hash ()))
+					 .build_shared ();
 		nano::publish publish3 (send3);
 		node1.network.process_message (publish1, node1.network.udp_channels.create (node1.network.endpoint ()));
 		node2.network.process_message (publish2, node2.network.udp_channels.create (node2.network.endpoint ()));
@@ -1341,20 +1341,20 @@ TEST (node, fork_bootstrap_flip)
 	nano::keypair key1;
 	nano::send_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .previous (latest)
-	             .destination (key1.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system0.work.generate (latest))
-	             .build_shared ();
+				 .previous (latest)
+				 .destination (key1.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system0.work.generate (latest))
+				 .build_shared ();
 	nano::keypair key2;
 	auto send2 = builder.make_block ()
-	             .previous (latest)
-	             .destination (key2.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system0.work.generate (latest))
-	             .build_shared ();
+				 .previous (latest)
+				 .destination (key2.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system0.work.generate (latest))
+				 .build_shared ();
 	// Insert but don't rebroadcast, simulating settled blocks
 	ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code);
 	ASSERT_EQ (nano::process_result::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2).code);
@@ -1377,12 +1377,12 @@ TEST (node, fork_open)
 	nano::keypair key1;
 	nano::genesis genesis;
 	auto send1 = nano::send_block_builder ()
-	             .previous (genesis.hash ())
-	             .destination (key1.pub)
-	             .balance (0)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key1.pub)
+				 .balance (0)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	nano::publish publish1 (send1);
 	auto channel1 (node1.network.udp_channels.create (node1.network.endpoint ()));
 	node1.network.process_message (publish1, channel1);
@@ -1394,24 +1394,24 @@ TEST (node, fork_open)
 	ASSERT_TIMELY (3s, node1.active.empty () && node1.block_confirmed (publish1.block->hash ()));
 	nano::open_block_builder builder;
 	auto open1 = builder.make_block ()
-	             .source (publish1.block->hash ())
-	             .representative (1)
-	             .account (key1.pub)
-	             .sign (key1.prv, key1.pub)
-	             .work (*system.work.generate (key1.pub))
-	             .build_shared ();
+				 .source (publish1.block->hash ())
+				 .representative (1)
+				 .account (key1.pub)
+				 .sign (key1.prv, key1.pub)
+				 .work (*system.work.generate (key1.pub))
+				 .build_shared ();
 	nano::publish publish2 (open1);
 	node1.network.process_message (publish2, channel1);
 	node1.block_processor.flush ();
 	node1.scheduler.flush ();
 	ASSERT_EQ (1, node1.active.size ());
 	auto open2 = builder.make_block ()
-	             .source (publish1.block->hash ())
-	             .representative (2)
-	             .account (key1.pub)
-	             .sign (key1.prv, key1.pub)
-	             .work (*system.work.generate (key1.pub))
-	             .build_shared ();
+				 .source (publish1.block->hash ())
+				 .representative (2)
+				 .account (key1.pub)
+				 .sign (key1.prv, key1.pub)
+				 .work (*system.work.generate (key1.pub))
+				 .build_shared ();
 	nano::publish publish3 (open2);
 	system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
 	node1.network.process_message (publish3, channel1);
@@ -1436,12 +1436,12 @@ TEST (node, fork_open_flip)
 	nano::keypair rep1;
 	nano::keypair rep2;
 	auto send1 = nano::send_block_builder ()
-	             .previous (genesis.hash ())
-	             .destination (key1.pub)
-	             .balance (nano::genesis_amount - 1)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key1.pub)
+				 .balance (nano::genesis_amount - 1)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	// A copy is necessary to avoid data races during ledger processing, which sets the sideband
 	auto send1_copy (std::make_shared<nano::send_block> (*send1));
 	node1.process_active (send1);
@@ -1449,20 +1449,20 @@ TEST (node, fork_open_flip)
 	// We should be keeping this block
 	nano::open_block_builder builder;
 	auto open1 = builder.make_block ()
-	             .source (send1->hash ())
-	             .representative (rep1.pub)
-	             .account (key1.pub)
-	             .sign (key1.prv, key1.pub)
-	             .work (*system.work.generate (key1.pub))
-	             .build_shared ();
+				 .source (send1->hash ())
+				 .representative (rep1.pub)
+				 .account (key1.pub)
+				 .sign (key1.prv, key1.pub)
+				 .work (*system.work.generate (key1.pub))
+				 .build_shared ();
 	// This block should be evicted
 	auto open2 = builder.make_block ()
-	             .source (send1->hash ())
-	             .representative (rep2.pub)
-	             .account (key1.pub)
-	             .sign (key1.prv, key1.pub)
-	             .work (*system.work.generate (key1.pub))
-	             .build_shared ();
+				 .source (send1->hash ())
+				 .representative (rep2.pub)
+				 .account (key1.pub)
+				 .sign (key1.prv, key1.pub)
+				 .work (*system.work.generate (key1.pub))
+				 .build_shared ();
 	ASSERT_FALSE (*open1 == *open2);
 	// node1 gets copy that will remain
 	node1.process_active (open1);
@@ -1537,12 +1537,12 @@ TEST (node, fork_no_vote_quorum)
 	ASSERT_EQ (nano::process_result::progress, node3.process (send1).code);
 	auto key2 (system.wallet (2)->deterministic_insert ());
 	auto send2 = nano::send_block_builder ()
-	             .previous (block->hash ())
-	             .destination (key2)
-	             .balance ((nano::genesis_amount / 4) - (node1.config.receive_minimum.number () * 2))
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (block->hash ()))
-	             .build_shared ();
+				 .previous (block->hash ())
+				 .destination (key2)
+				 .balance ((nano::genesis_amount / 4) - (node1.config.receive_minimum.number () * 2))
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (block->hash ()))
+				 .build_shared ();
 	nano::raw_key key3;
 	auto transaction (system.wallet (1)->wallets.tx_begin_read ());
 	ASSERT_FALSE (system.wallet (1)->store.fetch (transaction, key1, key3));
@@ -1593,23 +1593,23 @@ TEST (node, DISABLED_fork_pre_confirm)
 	nano::keypair key4;
 	nano::state_block_builder builder;
 	auto block2 = builder.make_block ()
-	              .account (nano::dev_genesis_key.pub)
-	              .previous (node0.latest (nano::dev_genesis_key.pub))
-	              .representative (key3.pub)
-	              .balance (node0.balance (nano::dev_genesis_key.pub))
-	              .link (0)
-	              .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	              .work (0)
-	              .build_shared ();
+				  .account (nano::dev_genesis_key.pub)
+				  .previous (node0.latest (nano::dev_genesis_key.pub))
+				  .representative (key3.pub)
+				  .balance (node0.balance (nano::dev_genesis_key.pub))
+				  .link (0)
+				  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				  .work (0)
+				  .build_shared ();
 	auto block3 = builder.make_block ()
-	              .account (nano::dev_genesis_key.pub)
-	              .previous (node0.latest (nano::dev_genesis_key.pub))
-	              .representative (key4.pub)
-	              .balance (node0.balance (nano::dev_genesis_key.pub))
-	              .link (0)
-	              .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	              .work (0)
-	              .build_shared ();
+				  .account (nano::dev_genesis_key.pub)
+				  .previous (node0.latest (nano::dev_genesis_key.pub))
+				  .representative (key4.pub)
+				  .balance (node0.balance (nano::dev_genesis_key.pub))
+				  .link (0)
+				  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				  .work (0)
+				  .build_shared ();
 	node0.work_generate_blocking (*block2);
 	node0.work_generate_blocking (*block3);
 	node0.process_active (block2);
@@ -1643,14 +1643,14 @@ TEST (node, DISABLED_fork_stale)
 	nano::keypair key2;
 	nano::state_block_builder builder;
 	auto send3 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - nano::Mxrb_ratio)
-	             .link (key1.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (0)
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - nano::Mxrb_ratio)
+				 .link (key1.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (0)
+				 .build_shared ();
 	node1.work_generate_blocking (*send3);
 	node1.process_active (send3);
 	system2.deadline_set (10s);
@@ -1660,24 +1660,24 @@ TEST (node, DISABLED_fork_stale)
 		ASSERT_NO_ERROR (system2.poll ());
 	}
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send3->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2 * nano::Mxrb_ratio)
-	             .link (key1.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (0)
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send3->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2 * nano::Mxrb_ratio)
+				 .link (key1.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (0)
+				 .build_shared ();
 	node1.work_generate_blocking (*send1);
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send3->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2 * nano::Mxrb_ratio)
-	             .link (key2.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (0)
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send3->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2 * nano::Mxrb_ratio)
+				 .link (key2.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (0)
+				 .build_shared ();
 	node1.work_generate_blocking (*send2);
 	{
 		auto transaction1 (node1.store.tx_begin_write ());
@@ -1726,47 +1726,47 @@ 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)
-			                 .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))
-			                 .build ();
+							 .previous (nano::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))
+							 .build ();
 			auto open_big = *builder.open ()
-			                 .source (fund_big.hash ())
-			                 .representative (rep_big.pub)
-			                 .account (rep_big.pub)
-			                 .sign (rep_big.prv, rep_big.pub)
-			                 .work (*system.work.generate (rep_big.pub))
-			                 .build ();
+							 .source (fund_big.hash ())
+							 .representative (rep_big.pub)
+							 .account (rep_big.pub)
+							 .sign (rep_big.prv, rep_big.pub)
+							 .work (*system.work.generate (rep_big.pub))
+							 .build ();
 			auto fund_small = *builder.send ()
-			                   .previous (fund_big.hash ())
-			                   .destination (rep_small.pub)
-			                   .balance (nano::Gxrb_ratio * 2)
-			                   .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-			                   .work (*system.work.generate (fund_big.hash ()))
-			                   .build ();
+							   .previous (fund_big.hash ())
+							   .destination (rep_small.pub)
+							   .balance (nano::Gxrb_ratio * 2)
+							   .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+							   .work (*system.work.generate (fund_big.hash ()))
+							   .build ();
 			auto open_small = *builder.open ()
-			                   .source (fund_small.hash ())
-			                   .representative (rep_small.pub)
-			                   .account (rep_small.pub)
-			                   .sign (rep_small.prv, rep_small.pub)
-			                   .work (*system.work.generate (rep_small.pub))
-			                   .build ();
+							   .source (fund_small.hash ())
+							   .representative (rep_small.pub)
+							   .account (rep_small.pub)
+							   .sign (rep_small.prv, rep_small.pub)
+							   .work (*system.work.generate (rep_small.pub))
+							   .build ();
 			auto fund_other = *builder.send ()
-			                   .previous (fund_small.hash ())
-			                   .destination (rep_other.pub)
-			                   .balance (nano::Gxrb_ratio)
-			                   .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-			                   .work (*system.work.generate (fund_small.hash ()))
-			                   .build ();
+							   .previous (fund_small.hash ())
+							   .destination (rep_other.pub)
+							   .balance (nano::Gxrb_ratio)
+							   .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+							   .work (*system.work.generate (fund_small.hash ()))
+							   .build ();
 			auto open_other = *builder.open ()
-			                   .source (fund_other.hash ())
-			                   .representative (rep_other.pub)
-			                   .account (rep_other.pub)
-			                   .sign (rep_other.prv, rep_other.pub)
-			                   .work (*system.work.generate (rep_other.pub))
-			                   .build ();
+							   .source (fund_other.hash ())
+							   .representative (rep_other.pub)
+							   .account (rep_other.pub)
+							   .sign (rep_other.prv, rep_other.pub)
+							   .work (*system.work.generate (rep_other.pub))
+							   .build ();
 			ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, fund_big).code);
 			ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, fund_big).code);
 			ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, fund_big).code);
@@ -1802,23 +1802,23 @@ TEST (node, broadcast_elected)
 		system.wallet (1)->insert_adhoc (rep_small.prv);
 		system.wallet (2)->insert_adhoc (rep_other.prv);
 		auto fork0 = builder.send ()
-		             .previous (node2->latest (nano::dev_genesis_key.pub))
-		             .destination (rep_small.pub)
-		             .balance (0)
-		             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		             .work (*node0->work_generate_blocking (node2->latest (nano::dev_genesis_key.pub)))
-		             .build_shared ();
+					 .previous (node2->latest (nano::dev_genesis_key.pub))
+					 .destination (rep_small.pub)
+					 .balance (0)
+					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					 .work (*node0->work_generate_blocking (node2->latest (nano::dev_genesis_key.pub)))
+					 .build_shared ();
 		// A copy is necessary to avoid data races during ledger processing, which sets the sideband
 		auto fork0_copy (std::make_shared<nano::send_block> (*fork0));
 		node0->process_active (fork0);
 		node1->process_active (fork0_copy);
 		auto fork1 = builder.send ()
-		             .previous (node2->latest (nano::dev_genesis_key.pub))
-		             .destination (rep_big.pub)
-		             .balance (0)
-		             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		             .work (*node0->work_generate_blocking (node2->latest (nano::dev_genesis_key.pub)))
-		             .build_shared ();
+					 .previous (node2->latest (nano::dev_genesis_key.pub))
+					 .destination (rep_big.pub)
+					 .balance (0)
+					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					 .work (*node0->work_generate_blocking (node2->latest (nano::dev_genesis_key.pub)))
+					 .build_shared ();
 		system.wallet (2)->insert_adhoc (rep_small.prv);
 		node2->process_active (fork1);
 		ASSERT_TIMELY (10s, node0->ledger.block_exists (fork0->hash ()) && node1->ledger.block_exists (fork0->hash ()));
@@ -1844,19 +1844,19 @@ TEST (node, rep_self_vote)
 	nano::keypair rep_big;
 	nano::block_builder builder;
 	auto fund_big = *builder.send ()
-	                 .previous (nano::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))
-	                 .build ();
+					 .previous (nano::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))
+					 .build ();
 	auto open_big = *builder.open ()
-	                 .source (fund_big.hash ())
-	                 .representative (rep_big.pub)
-	                 .account (rep_big.pub)
-	                 .sign (rep_big.prv, rep_big.pub)
-	                 .work (*system.work.generate (rep_big.pub))
-	                 .build ();
+					 .source (fund_big.hash ())
+					 .representative (rep_big.pub)
+					 .account (rep_big.pub)
+					 .sign (rep_big.prv, rep_big.pub)
+					 .work (*system.work.generate (rep_big.pub))
+					 .build ();
 	ASSERT_EQ (nano::process_result::progress, node0->process (fund_big).code);
 	ASSERT_EQ (nano::process_result::progress, node0->process (open_big).code);
 	// Confirm both blocks, allowing voting on the upcoming block
@@ -1869,12 +1869,12 @@ TEST (node, rep_self_vote)
 	system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
 	ASSERT_EQ (system.wallet (0)->wallets.reps ().voting, 2);
 	auto block0 = builder.send ()
-	              .previous (fund_big.hash ())
-	              .destination (rep_big.pub)
-	              .balance (nano::uint128_t ("0x60000000000000000000000000000000"))
-	              .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	              .work (*system.work.generate (fund_big.hash ()))
-	              .build_shared ();
+				  .previous (fund_big.hash ())
+				  .destination (rep_big.pub)
+				  .balance (nano::uint128_t ("0x60000000000000000000000000000000"))
+				  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				  .work (*system.work.generate (fund_big.hash ()))
+				  .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node0->process (*block0).code);
 	auto & active = node0->active;
 	auto & scheduler = node0->scheduler;
@@ -1932,12 +1932,12 @@ 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)
-	             .destination (key0.pub)
-	             .balance (500)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node0->work_generate_blocking (nano::genesis_hash))
-	             .build_shared ();
+				 .previous (nano::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))
+				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node0->process (*send0).code);
 
 	ASSERT_FALSE (node0->bootstrap_initiator.in_progress ());
@@ -1970,26 +1970,26 @@ TEST (node, bootstrap_fork_open)
 	nano::keypair key0;
 	nano::block_builder builder;
 	auto send0 = *builder.send ()
-	              .previous (nano::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))
-	              .build ();
+				  .previous (nano::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))
+				  .build ();
 	auto open0 = *builder.open ()
-	              .source (send0.hash ())
-	              .representative (1)
-	              .account (key0.pub)
-	              .sign (key0.prv, key0.pub)
-	              .work (*system.work.generate (key0.pub))
-	              .build ();
+				  .source (send0.hash ())
+				  .representative (1)
+				  .account (key0.pub)
+				  .sign (key0.prv, key0.pub)
+				  .work (*system.work.generate (key0.pub))
+				  .build ();
 	auto open1 = *builder.open ()
-	              .source (send0.hash ())
-	              .representative (2)
-	              .account (key0.pub)
-	              .sign (key0.prv, key0.pub)
-	              .work (*system.work.generate (key0.pub))
-	              .build ();
+				  .source (send0.hash ())
+				  .representative (2)
+				  .account (key0.pub)
+				  .sign (key0.prv, key0.pub)
+				  .work (*system.work.generate (key0.pub))
+				  .build ();
 	// Both know about send0
 	ASSERT_EQ (nano::process_result::progress, node0->process (send0).code);
 	ASSERT_EQ (nano::process_result::progress, node1->process (send0).code);
@@ -2026,12 +2026,12 @@ 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)
-	             .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))
-	             .build_shared ();
+				 .previous (nano::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))
+				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node0->process (*send0).code);
 
 	ASSERT_FALSE (node0->bootstrap_initiator.in_progress ());
@@ -2142,45 +2142,45 @@ TEST (node, rep_weight)
 	auto amount_pr (node.minimum_principal_weight () + 100);
 	auto amount_not_pr (node.minimum_principal_weight () - 100);
 	std::shared_ptr<nano::block> block1 = builder
-	                                      .state ()
-	                                      .account (nano::dev_genesis_key.pub)
-	                                      .previous (genesis.hash ())
-	                                      .representative (nano::dev_genesis_key.pub)
-	                                      .balance (nano::genesis_amount - amount_not_pr)
-	                                      .link (keypair1.pub)
-	                                      .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                                      .work (*system.work.generate (genesis.hash ()))
-	                                      .build ();
+										  .state ()
+										  .account (nano::dev_genesis_key.pub)
+										  .previous (genesis.hash ())
+										  .representative (nano::dev_genesis_key.pub)
+										  .balance (nano::genesis_amount - amount_not_pr)
+										  .link (keypair1.pub)
+										  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+										  .work (*system.work.generate (genesis.hash ()))
+										  .build ();
 	std::shared_ptr<nano::block> block2 = builder
-	                                      .state ()
-	                                      .account (keypair1.pub)
-	                                      .previous (0)
-	                                      .representative (keypair1.pub)
-	                                      .balance (amount_not_pr)
-	                                      .link (block1->hash ())
-	                                      .sign (keypair1.prv, keypair1.pub)
-	                                      .work (*system.work.generate (keypair1.pub))
-	                                      .build ();
+										  .state ()
+										  .account (keypair1.pub)
+										  .previous (0)
+										  .representative (keypair1.pub)
+										  .balance (amount_not_pr)
+										  .link (block1->hash ())
+										  .sign (keypair1.prv, keypair1.pub)
+										  .work (*system.work.generate (keypair1.pub))
+										  .build ();
 	std::shared_ptr<nano::block> block3 = builder
-	                                      .state ()
-	                                      .account (nano::dev_genesis_key.pub)
-	                                      .previous (block1->hash ())
-	                                      .representative (nano::dev_genesis_key.pub)
-	                                      .balance (nano::genesis_amount - amount_not_pr - amount_pr)
-	                                      .link (keypair2.pub)
-	                                      .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                                      .work (*system.work.generate (block1->hash ()))
-	                                      .build ();
+										  .state ()
+										  .account (nano::dev_genesis_key.pub)
+										  .previous (block1->hash ())
+										  .representative (nano::dev_genesis_key.pub)
+										  .balance (nano::genesis_amount - amount_not_pr - amount_pr)
+										  .link (keypair2.pub)
+										  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+										  .work (*system.work.generate (block1->hash ()))
+										  .build ();
 	std::shared_ptr<nano::block> block4 = builder
-	                                      .state ()
-	                                      .account (keypair2.pub)
-	                                      .previous (0)
-	                                      .representative (keypair2.pub)
-	                                      .balance (amount_pr)
-	                                      .link (block3->hash ())
-	                                      .sign (keypair2.prv, keypair2.pub)
-	                                      .work (*system.work.generate (keypair2.pub))
-	                                      .build ();
+										  .state ()
+										  .account (keypair2.pub)
+										  .previous (0)
+										  .representative (keypair2.pub)
+										  .balance (amount_pr)
+										  .link (block3->hash ())
+										  .sign (keypair2.prv, keypair2.pub)
+										  .work (*system.work.generate (keypair2.pub))
+										  .build ();
 	{
 		auto transaction = node.store.tx_begin_write ();
 		ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *block1).code);
@@ -2224,45 +2224,45 @@ TEST (node, rep_remove)
 	nano::keypair keypair2;
 	nano::block_builder builder;
 	std::shared_ptr<nano::block> block1 = builder
-	                                      .state ()
-	                                      .account (nano::dev_genesis_key.pub)
-	                                      .previous (genesis.hash ())
-	                                      .representative (nano::dev_genesis_key.pub)
-	                                      .balance (nano::genesis_amount - node.minimum_principal_weight () * 2)
-	                                      .link (keypair1.pub)
-	                                      .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                                      .work (*system.work.generate (genesis.hash ()))
-	                                      .build ();
+										  .state ()
+										  .account (nano::dev_genesis_key.pub)
+										  .previous (genesis.hash ())
+										  .representative (nano::dev_genesis_key.pub)
+										  .balance (nano::genesis_amount - node.minimum_principal_weight () * 2)
+										  .link (keypair1.pub)
+										  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+										  .work (*system.work.generate (genesis.hash ()))
+										  .build ();
 	std::shared_ptr<nano::block> block2 = builder
-	                                      .state ()
-	                                      .account (keypair1.pub)
-	                                      .previous (0)
-	                                      .representative (keypair1.pub)
-	                                      .balance (node.minimum_principal_weight () * 2)
-	                                      .link (block1->hash ())
-	                                      .sign (keypair1.prv, keypair1.pub)
-	                                      .work (*system.work.generate (keypair1.pub))
-	                                      .build ();
+										  .state ()
+										  .account (keypair1.pub)
+										  .previous (0)
+										  .representative (keypair1.pub)
+										  .balance (node.minimum_principal_weight () * 2)
+										  .link (block1->hash ())
+										  .sign (keypair1.prv, keypair1.pub)
+										  .work (*system.work.generate (keypair1.pub))
+										  .build ();
 	std::shared_ptr<nano::block> block3 = builder
-	                                      .state ()
-	                                      .account (nano::dev_genesis_key.pub)
-	                                      .previous (block1->hash ())
-	                                      .representative (nano::dev_genesis_key.pub)
-	                                      .balance (nano::genesis_amount - node.minimum_principal_weight () * 4)
-	                                      .link (keypair2.pub)
-	                                      .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                                      .work (*system.work.generate (block1->hash ()))
-	                                      .build ();
+										  .state ()
+										  .account (nano::dev_genesis_key.pub)
+										  .previous (block1->hash ())
+										  .representative (nano::dev_genesis_key.pub)
+										  .balance (nano::genesis_amount - node.minimum_principal_weight () * 4)
+										  .link (keypair2.pub)
+										  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+										  .work (*system.work.generate (block1->hash ()))
+										  .build ();
 	std::shared_ptr<nano::block> block4 = builder
-	                                      .state ()
-	                                      .account (keypair2.pub)
-	                                      .previous (0)
-	                                      .representative (keypair2.pub)
-	                                      .balance (node.minimum_principal_weight () * 2)
-	                                      .link (block3->hash ())
-	                                      .sign (keypair2.prv, keypair2.pub)
-	                                      .work (*system.work.generate (keypair2.pub))
-	                                      .build ();
+										  .state ()
+										  .account (keypair2.pub)
+										  .previous (0)
+										  .representative (keypair2.pub)
+										  .balance (node.minimum_principal_weight () * 2)
+										  .link (block3->hash ())
+										  .sign (keypair2.prv, keypair2.pub)
+										  .work (*system.work.generate (keypair2.pub))
+										  .build ();
 	{
 		auto transaction = node.store.tx_begin_write ();
 		ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *block1).code);
@@ -2530,14 +2530,14 @@ TEST (node, online_reps_election)
 	nano::keypair key;
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .link (key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node1.work_generate_blocking (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .link (key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node1.work_generate_blocking (genesis.hash ()))
+				 .build_shared ();
 	node1.process_active (send1);
 	node1.block_processor.flush ();
 	node1.scheduler.flush ();
@@ -2569,18 +2569,18 @@ TEST (node, block_confirm)
 		nano::state_block_builder builder;
 		system.wallet (1)->insert_adhoc (nano::dev_genesis_key.prv);
 		auto send1 = builder.make_block ()
-		             .account (nano::dev_genesis_key.pub)
-		             .previous (genesis.hash ())
-		             .representative (nano::dev_genesis_key.pub)
-		             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-		             .link (key.pub)
-		             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		             .work (*node1.work_generate_blocking (genesis.hash ()))
-		             .build_shared ();
+					 .account (nano::dev_genesis_key.pub)
+					 .previous (genesis.hash ())
+					 .representative (nano::dev_genesis_key.pub)
+					 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+					 .link (key.pub)
+					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					 .work (*node1.work_generate_blocking (genesis.hash ()))
+					 .build_shared ();
 		// A copy is necessary to avoid data races during ledger processing, which sets the sideband
 		auto send1_copy = builder.make_block ()
-		                  .from (*send1)
-		                  .build_shared ();
+						  .from (*send1)
+						  .build_shared ();
 		node1.block_processor.add (send1, nano::seconds_since_epoch ());
 		node2.block_processor.add (send1_copy, nano::seconds_since_epoch ());
 		ASSERT_TIMELY (5s, node1.ledger.block_exists (send1->hash ()) && node2.ledger.block_exists (send1_copy->hash ()));
@@ -2650,14 +2650,14 @@ TEST (node, confirm_quorum)
 	// Put greater than node.delta () in pending so quorum can't be reached
 	nano::amount new_balance = node1.online_reps.delta () - nano::Gxrb_ratio;
 	auto send1 = nano::state_block_builder ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (new_balance)
-	             .link (nano::dev_genesis_key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node1.work_generate_blocking (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (new_balance)
+				 .link (nano::dev_genesis_key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node1.work_generate_blocking (genesis.hash ()))
+				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code);
 	system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, new_balance.number ());
 	ASSERT_TIMELY (1s, node1.active.election (send1->qualified_root ()));
@@ -2678,32 +2678,32 @@ TEST (node, local_votes_cache)
 	nano::genesis genesis;
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (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 (*node.work_generate_blocking (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (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 (*node.work_generate_blocking (genesis.hash ()))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send1->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
-	             .link (nano::dev_genesis_key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node.work_generate_blocking (send1->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send1->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
+				 .link (nano::dev_genesis_key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node.work_generate_blocking (send1->hash ()))
+				 .build_shared ();
 	auto send3 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send2->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 3 * nano::Gxrb_ratio)
-	             .link (nano::dev_genesis_key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node.work_generate_blocking (send2->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send2->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 3 * nano::Gxrb_ratio)
+				 .link (nano::dev_genesis_key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node.work_generate_blocking (send2->hash ()))
+				 .build_shared ();
 	{
 		auto transaction (node.store.tx_begin_write ());
 		ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *send1).code);
@@ -2765,36 +2765,36 @@ TEST (node, local_votes_cache_batch)
 	system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
 	nano::keypair key1;
 	auto send1 = nano::state_block_builder ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .link (key1.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node.work_generate_blocking (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .link (key1.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node.work_generate_blocking (genesis.hash ()))
+				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
 	node.confirmation_height_processor.add (send1);
 	ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ()));
 	auto send2 = nano::state_block_builder ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send1->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
-	             .link (nano::dev_genesis_key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node.work_generate_blocking (send1->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send1->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
+				 .link (nano::dev_genesis_key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node.work_generate_blocking (send1->hash ()))
+				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
 	auto receive1 = nano::state_block_builder ()
-	                .account (key1.pub)
-	                .previous (0)
-	                .representative (nano::dev_genesis_key.pub)
-	                .balance (nano::Gxrb_ratio)
-	                .link (send1->hash ())
-	                .sign (key1.prv, key1.pub)
-	                .work (*node.work_generate_blocking (key1.pub))
-	                .build_shared ();
+					.account (key1.pub)
+					.previous (0)
+					.representative (nano::dev_genesis_key.pub)
+					.balance (nano::Gxrb_ratio)
+					.link (send1->hash ())
+					.sign (key1.prv, key1.pub)
+					.work (*node.work_generate_blocking (key1.pub))
+					.build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code);
 	std::vector<std::pair<nano::block_hash, nano::root>> batch{ { send2->hash (), send2->root () }, { receive1->hash (), receive1->root () } };
 	nano::confirm_req message (batch);
@@ -2843,14 +2843,14 @@ TEST (node, local_votes_cache_generate_new_vote)
 	ASSERT_EQ (genesis.open->hash (), boost::get<nano::block_hash> (votes1[0]->blocks[0]));
 	ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_votes) == 1);
 	auto send1 = nano::state_block_builder ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (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 (*node.work_generate_blocking (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (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 (*node.work_generate_blocking (genesis.hash ()))
+				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.process (*send1).code);
 	// One of the hashes is cached
 	std::vector<std::pair<nano::block_hash, nano::root>> roots_hashes{ std::make_pair (genesis.open->hash (), genesis.open->root ()), std::make_pair (send1->hash (), send1->root ()) };
@@ -2883,23 +2883,23 @@ TEST (node, local_votes_cache_fork)
 	nano::genesis genesis;
 	system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
 	auto send1 = nano::state_block_builder ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (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 (*node1.work_generate_blocking (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (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 (*node1.work_generate_blocking (genesis.hash ()))
+				 .build_shared ();
 	auto send1_fork = nano::state_block_builder ()
-	                  .account (nano::dev_genesis_key.pub)
-	                  .previous (genesis.hash ())
-	                  .representative (nano::dev_genesis_key.pub)
-	                  .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
-	                  .link (nano::dev_genesis_key.pub)
-	                  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                  .work (*node1.work_generate_blocking (genesis.hash ()))
-	                  .build_shared ();
+					  .account (nano::dev_genesis_key.pub)
+					  .previous (genesis.hash ())
+					  .representative (nano::dev_genesis_key.pub)
+					  .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
+					  .link (nano::dev_genesis_key.pub)
+					  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					  .work (*node1.work_generate_blocking (genesis.hash ()))
+					  .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code);
 	// Cache vote
 	auto vote (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, std::vector<nano::block_hash> (1, send1->hash ())));
@@ -2926,19 +2926,19 @@ TEST (node, vote_republish)
 	nano::genesis genesis;
 	nano::send_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .previous (genesis.hash ())
-	             .destination (key2.pub)
-	             .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key2.pub)
+				 .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .previous (genesis.hash ())
-	             .destination (key2.pub)
-	             .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number () * 2)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key2.pub)
+				 .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number () * 2)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	node1.process_active (send1);
 	ASSERT_TIMELY (5s, node2.block (send1->hash ()));
 	node1.active.publish (send2);
@@ -2963,25 +2963,25 @@ TEST (node, vote_by_hash_bundle)
 	nano::state_block_builder builder;
 	std::vector<std::shared_ptr<nano::state_block>> blocks;
 	auto block = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::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))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::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))
+				 .build_shared ();
 	blocks.push_back (block);
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ()).code);
 	for (auto i = 2; i < 200; ++i)
 	{
 		auto block = builder.make_block ()
-		             .from (*blocks.back ())
-		             .previous (blocks.back ()->hash ())
-		             .balance (nano::genesis_amount - i)
-		             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		             .work (*system.work.generate (blocks.back ()->hash ()))
-		             .build_shared ();
+					 .from (*blocks.back ())
+					 .previous (blocks.back ()->hash ())
+					 .balance (nano::genesis_amount - i)
+					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					 .work (*system.work.generate (blocks.back ()->hash ()))
+					 .build_shared ();
 		blocks.push_back (block);
 		ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ()).code);
 	}
@@ -3020,19 +3020,19 @@ TEST (node, vote_by_hash_republish)
 	nano::genesis genesis;
 	nano::send_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .previous (genesis.hash ())
-	             .destination (key2.pub)
-	             .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key2.pub)
+				 .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .previous (genesis.hash ())
-	             .destination (key2.pub)
-	             .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number () * 2)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key2.pub)
+				 .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number () * 2)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	node1.process_active (send1);
 	ASSERT_TIMELY (5s, node2.active.active (*send1));
 	node1.process_active (send2);
@@ -3059,21 +3059,21 @@ TEST (node, vote_by_hash_epoch_block_republish)
 	system.wallet (1)->insert_adhoc (key2.prv);
 	nano::genesis genesis;
 	auto send1 = nano::send_block_builder ()
-	             .previous (genesis.hash ())
-	             .destination (key2.pub)
-	             .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key2.pub)
+				 .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	auto epoch1 = nano::state_block_builder ()
-	              .account (nano::genesis_account)
-	              .previous (genesis.hash ())
-	              .representative (nano::genesis_account)
-	              .balance (nano::genesis_amount)
-	              .link (node1.ledger.epoch_link (nano::epoch::epoch_1))
-	              .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	              .work (*system.work.generate (genesis.hash ()))
-	              .build_shared ();
+				  .account (nano::genesis_account)
+				  .previous (genesis.hash ())
+				  .representative (nano::genesis_account)
+				  .balance (nano::genesis_amount)
+				  .link (node1.ledger.epoch_link (nano::epoch::epoch_1))
+				  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				  .work (*system.work.generate (genesis.hash ()))
+				  .build_shared ();
 	node1.process_active (send1);
 	ASSERT_TIMELY (5s, node2.active.active (*send1));
 	node1.active.publish (epoch1);
@@ -3102,50 +3102,50 @@ TEST (node, epoch_conflict_confirm)
 	nano::keypair epoch_signer (nano::dev_genesis_key);
 	nano::state_block_builder builder;
 	auto send = builder.make_block ()
-	            .account (nano::dev_genesis_key.pub)
-	            .previous (genesis.hash ())
-	            .representative (nano::dev_genesis_key.pub)
-	            .balance (nano::genesis_amount - 1)
-	            .link (key.pub)
-	            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	            .work (*system.work.generate (genesis.hash ()))
-	            .build_shared ();
+				.account (nano::dev_genesis_key.pub)
+				.previous (genesis.hash ())
+				.representative (nano::dev_genesis_key.pub)
+				.balance (nano::genesis_amount - 1)
+				.link (key.pub)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*system.work.generate (genesis.hash ()))
+				.build_shared ();
 	auto open = builder.make_block ()
-	            .account (key.pub)
-	            .previous (0)
-	            .representative (key.pub)
-	            .balance (1)
-	            .link (send->hash ())
-	            .sign (key.prv, key.pub)
-	            .work (*system.work.generate (key.pub))
-	            .build_shared ();
+				.account (key.pub)
+				.previous (0)
+				.representative (key.pub)
+				.balance (1)
+				.link (send->hash ())
+				.sign (key.prv, key.pub)
+				.work (*system.work.generate (key.pub))
+				.build_shared ();
 	auto change = builder.make_block ()
-	              .account (key.pub)
-	              .previous (open->hash ())
-	              .representative (key.pub)
-	              .balance (1)
-	              .link (0)
-	              .sign (key.prv, key.pub)
-	              .work (*system.work.generate (open->hash ()))
-	              .build_shared ();
+				  .account (key.pub)
+				  .previous (open->hash ())
+				  .representative (key.pub)
+				  .balance (1)
+				  .link (0)
+				  .sign (key.prv, key.pub)
+				  .work (*system.work.generate (open->hash ()))
+				  .build_shared ();
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2)
-	             .link (open->hash ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2)
+				 .link (open->hash ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send->hash ()))
+				 .build_shared ();
 	auto epoch_open = builder.make_block ()
-	                  .account (change->root ().as_account ())
-	                  .previous (0)
-	                  .representative (0)
-	                  .balance (0)
-	                  .link (node0->ledger.epoch_link (nano::epoch::epoch_1))
-	                  .sign (epoch_signer.prv, epoch_signer.pub)
-	                  .work (*system.work.generate (open->hash ()))
-	                  .build_shared ();
+					  .account (change->root ().as_account ())
+					  .previous (0)
+					  .representative (0)
+					  .balance (0)
+					  .link (node0->ledger.epoch_link (nano::epoch::epoch_1))
+					  .sign (epoch_signer.prv, epoch_signer.pub)
+					  .work (*system.work.generate (open->hash ()))
+					  .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node1->process (*send).code);
 	ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code);
 	ASSERT_EQ (nano::process_result::progress, node1->process (*open).code);
@@ -3198,19 +3198,19 @@ TEST (node, fork_invalid_block_signature)
 	nano::genesis genesis;
 	nano::send_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .previous (genesis.hash ())
-	             .destination (key2.pub)
-	             .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number ())
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key2.pub)
+				 .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number ())
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .previous (genesis.hash ())
-	             .destination (key2.pub)
-	             .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number () * 2)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key2.pub)
+				 .balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.receive_minimum.number () * 2)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	auto send2_corrupt (std::make_shared<nano::send_block> (*send2));
 	send2_corrupt->signature = nano::signature (123);
 	auto vote (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, send2));
@@ -3236,32 +3236,32 @@ TEST (node, fork_election_invalid_block_signature)
 	nano::genesis genesis;
 	nano::block_builder builder;
 	auto send1 = builder.state ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .link (nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .link (nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .build_shared ();
 	auto send2 = builder.state ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
-	             .link (nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
+				 .link (nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .build_shared ();
 	auto send3 = builder.state ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
-	             .link (nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .sign (nano::dev_genesis_key.prv, 0) // Invalid signature
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
+				 .link (nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .sign (nano::dev_genesis_key.prv, 0) // Invalid signature
+				 .build_shared ();
 	auto channel1 (node1.network.udp_channels.create (node1.network.endpoint ()));
 	node1.network.process_message (nano::publish (send1), channel1);
 	ASSERT_TIMELY (5s, node1.active.active (send1->qualified_root ()));
@@ -3285,53 +3285,53 @@ TEST (node, block_processor_signatures)
 	nano::keypair key2;
 	nano::keypair key3;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (latest)
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .link (key1.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node1.work_generate_blocking (latest))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (latest)
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .link (key1.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node1.work_generate_blocking (latest))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send1->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
-	             .link (key2.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node1.work_generate_blocking (send1->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send1->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
+				 .link (key2.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node1.work_generate_blocking (send1->hash ()))
+				 .build_shared ();
 	auto send3 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send2->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 3 * nano::Gxrb_ratio)
-	             .link (key3.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node1.work_generate_blocking (send2->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send2->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 3 * nano::Gxrb_ratio)
+				 .link (key3.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node1.work_generate_blocking (send2->hash ()))
+				 .build_shared ();
 	// Invalid signature bit
 	auto send4 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send3->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 4 * nano::Gxrb_ratio)
-	             .link (key3.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node1.work_generate_blocking (send3->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send3->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 4 * nano::Gxrb_ratio)
+				 .link (key3.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node1.work_generate_blocking (send3->hash ()))
+				 .build_shared ();
 	send4->signature.bytes[32] ^= 0x1;
 	// Invalid signature bit (force)
 	auto send5 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send3->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 5 * nano::Gxrb_ratio)
-	             .link (key3.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node1.work_generate_blocking (send3->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send3->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 5 * nano::Gxrb_ratio)
+				 .link (key3.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node1.work_generate_blocking (send3->hash ()))
+				 .build_shared ();
 	send5->signature.bytes[31] ^= 0x1;
 	// Invalid signature to unchecked
 	{
@@ -3339,33 +3339,33 @@ TEST (node, block_processor_signatures)
 		node1.store.unchecked_put (transaction, send5->previous (), send5);
 	}
 	auto receive1 = builder.make_block ()
-	                .account (key1.pub)
-	                .previous (0)
-	                .representative (nano::dev_genesis_key.pub)
-	                .balance (nano::Gxrb_ratio)
-	                .link (send1->hash ())
-	                .sign (key1.prv, key1.pub)
-	                .work (*node1.work_generate_blocking (key1.pub))
-	                .build_shared ();
+					.account (key1.pub)
+					.previous (0)
+					.representative (nano::dev_genesis_key.pub)
+					.balance (nano::Gxrb_ratio)
+					.link (send1->hash ())
+					.sign (key1.prv, key1.pub)
+					.work (*node1.work_generate_blocking (key1.pub))
+					.build_shared ();
 	auto receive2 = builder.make_block ()
-	                .account (key2.pub)
-	                .previous (0)
-	                .representative (nano::dev_genesis_key.pub)
-	                .balance (nano::Gxrb_ratio)
-	                .link (send2->hash ())
-	                .sign (key2.prv, key2.pub)
-	                .work (*node1.work_generate_blocking (key2.pub))
-	                .build_shared ();
+					.account (key2.pub)
+					.previous (0)
+					.representative (nano::dev_genesis_key.pub)
+					.balance (nano::Gxrb_ratio)
+					.link (send2->hash ())
+					.sign (key2.prv, key2.pub)
+					.work (*node1.work_generate_blocking (key2.pub))
+					.build_shared ();
 	// Invalid private key
 	auto receive3 = builder.make_block ()
-	                .account (key3.pub)
-	                .previous (0)
-	                .representative (nano::dev_genesis_key.pub)
-	                .balance (nano::Gxrb_ratio)
-	                .link (send3->hash ())
-	                .sign (key2.prv, key3.pub)
-	                .work (*node1.work_generate_blocking (key3.pub))
-	                .build_shared ();
+					.account (key3.pub)
+					.previous (0)
+					.representative (nano::dev_genesis_key.pub)
+					.balance (nano::Gxrb_ratio)
+					.link (send3->hash ())
+					.sign (key2.prv, key3.pub)
+					.work (*node1.work_generate_blocking (key3.pub))
+					.build_shared ();
 	node1.process_active (send1);
 	node1.process_active (send2);
 	node1.process_active (send3);
@@ -3398,14 +3398,14 @@ TEST (node, block_processor_reject_state)
 	nano::genesis genesis;
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (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 (*node.work_generate_blocking (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (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 (*node.work_generate_blocking (genesis.hash ()))
+				 .build_shared ();
 	send1->signature.bytes[0] ^= 1;
 	ASSERT_FALSE (node.ledger.block_exists (send1->hash ()));
 	node.process_active (send1);
@@ -3413,14 +3413,14 @@ TEST (node, block_processor_reject_state)
 	ASSERT_NE (std::future_status::timeout, flushed.wait_for (5s));
 	ASSERT_FALSE (node.ledger.block_exists (send1->hash ()));
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
-	             .link (nano::dev_genesis_key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node.work_generate_blocking (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
+				 .link (nano::dev_genesis_key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node.work_generate_blocking (genesis.hash ()))
+				 .build_shared ();
 	node.process_active (send2);
 	auto flushed2 = std::async (std::launch::async, [&node] { node.block_processor.flush (); });
 	ASSERT_NE (std::future_status::timeout, flushed2.wait_for (5s));
@@ -3437,32 +3437,32 @@ TEST (node, block_processor_full)
 	nano::genesis genesis;
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (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 (*node.work_generate_blocking (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (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 (*node.work_generate_blocking (genesis.hash ()))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send1->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
-	             .link (nano::dev_genesis_key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node.work_generate_blocking (send1->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send1->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
+				 .link (nano::dev_genesis_key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node.work_generate_blocking (send1->hash ()))
+				 .build_shared ();
 	auto send3 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send2->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 3 * nano::Gxrb_ratio)
-	             .link (nano::dev_genesis_key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node.work_generate_blocking (send2->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send2->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 3 * nano::Gxrb_ratio)
+				 .link (nano::dev_genesis_key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node.work_generate_blocking (send2->hash ()))
+				 .build_shared ();
 	// The write guard prevents block processor doing any writes
 	auto write_guard = node.write_database_queue.wait (nano::writer::testing);
 	node.block_processor.add (send1);
@@ -3484,32 +3484,32 @@ TEST (node, block_processor_half_full)
 	nano::genesis genesis;
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (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 (*node.work_generate_blocking (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (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 (*node.work_generate_blocking (genesis.hash ()))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send1->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
-	             .link (nano::dev_genesis_key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node.work_generate_blocking (send1->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send1->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
+				 .link (nano::dev_genesis_key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node.work_generate_blocking (send1->hash ()))
+				 .build_shared ();
 	auto send3 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send2->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 3 * nano::Gxrb_ratio)
-	             .link (nano::dev_genesis_key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node.work_generate_blocking (send2->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send2->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 3 * nano::Gxrb_ratio)
+				 .link (nano::dev_genesis_key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node.work_generate_blocking (send2->hash ()))
+				 .build_shared ();
 	// The write guard prevents block processor doing any writes
 	auto write_guard = node.write_database_queue.wait (nano::writer::testing);
 	node.block_processor.add (send1);
@@ -3530,31 +3530,31 @@ TEST (node, confirm_back)
 	nano::genesis genesis;
 	auto genesis_start_balance (node.balance (nano::dev_genesis_key.pub));
 	auto send1 = nano::send_block_builder ()
-	             .previous (genesis.hash ())
-	             .destination (key.pub)
-	             .balance (genesis_start_balance - 1)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key.pub)
+				 .balance (genesis_start_balance - 1)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	nano::state_block_builder builder;
 	auto open = builder.make_block ()
-	            .account (key.pub)
-	            .previous (0)
-	            .representative (key.pub)
-	            .balance (1)
-	            .link (send1->hash ())
-	            .sign (key.prv, key.pub)
-	            .work (*system.work.generate (key.pub))
-	            .build_shared ();
+				.account (key.pub)
+				.previous (0)
+				.representative (key.pub)
+				.balance (1)
+				.link (send1->hash ())
+				.sign (key.prv, key.pub)
+				.work (*system.work.generate (key.pub))
+				.build_shared ();
 	auto send2 = builder.make_block ()
-	             .account (key.pub)
-	             .previous (open->hash ())
-	             .representative (key.pub)
-	             .balance (0)
-	             .link (nano::dev_genesis_key.pub)
-	             .sign (key.prv, key.pub)
-	             .work (*system.work.generate (open->hash ()))
-	             .build_shared ();
+				 .account (key.pub)
+				 .previous (open->hash ())
+				 .representative (key.pub)
+				 .balance (0)
+				 .link (nano::dev_genesis_key.pub)
+				 .sign (key.prv, key.pub)
+				 .work (*system.work.generate (open->hash ()))
+				 .build_shared ();
 	node.process_active (send1);
 	node.process_active (open);
 	node.process_active (send2);
@@ -3674,14 +3674,14 @@ TEST (node, unchecked_cleanup)
 	nano::keypair key;
 	auto & node (*system.add_node (node_flags));
 	auto open = nano::state_block_builder ()
-	            .account (key.pub)
-	            .previous (0)
-	            .representative (key.pub)
-	            .balance (1)
-	            .link (key.pub)
-	            .sign (key.prv, key.pub)
-	            .work (*system.work.generate (key.pub))
-	            .build_shared ();
+				.account (key.pub)
+				.previous (0)
+				.representative (key.pub)
+				.balance (1)
+				.link (key.pub)
+				.sign (key.prv, key.pub)
+				.work (*system.work.generate (key.pub))
+				.build_shared ();
 	std::vector<uint8_t> bytes;
 	{
 		nano::vectorstream stream (bytes);
@@ -3787,14 +3787,14 @@ TEST (node, bidirectional_tcp)
 	nano::keypair key;
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .link (key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node1->work_generate_blocking (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .link (key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node1->work_generate_blocking (genesis.hash ()))
+				 .build_shared ();
 	node1->process_active (send1);
 	node1->block_processor.flush ();
 	ASSERT_TIMELY (10s, node1->ledger.block_exists (send1->hash ()) && node2->ledger.block_exists (send1->hash ()));
@@ -3821,14 +3821,14 @@ TEST (node, bidirectional_tcp)
 	/* Test block propagation from node 2
 	Node 2 has only ephemeral TCP port open. Node 1 cannot establish connection to node 2 listening port */
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send1->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
-	             .link (key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node1->work_generate_blocking (send1->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send1->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
+				 .link (key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node1->work_generate_blocking (send1->hash ()))
+				 .build_shared ();
 	node2->process_active (send2);
 	node2->block_processor.flush ();
 	ASSERT_TIMELY (10s, node1->ledger.block_exists (send2->hash ()) && node2->ledger.block_exists (send2->hash ()));
@@ -3911,14 +3911,14 @@ TEST (node, aggressive_flooding)
 	{
 		auto transaction (node1.store.tx_begin_read ());
 		block = builder.make_block ()
-		        .account (nano::dev_genesis_key.pub)
-		        .representative (nano::dev_genesis_key.pub)
-		        .previous (node1.ledger.latest (transaction, nano::dev_genesis_key.pub))
-		        .balance (node1.ledger.account_balance (transaction, nano::dev_genesis_key.pub) - 1)
-		        .link (nano::dev_genesis_key.pub)
-		        .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		        .work (*node1.work_generate_blocking (node1.ledger.latest (transaction, nano::dev_genesis_key.pub)))
-		        .build ();
+				.account (nano::dev_genesis_key.pub)
+				.representative (nano::dev_genesis_key.pub)
+				.previous (node1.ledger.latest (transaction, nano::dev_genesis_key.pub))
+				.balance (node1.ledger.account_balance (transaction, nano::dev_genesis_key.pub) - 1)
+				.link (nano::dev_genesis_key.pub)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.work (*node1.work_generate_blocking (node1.ledger.latest (transaction, nano::dev_genesis_key.pub)))
+				.build ();
 	}
 	// Processing locally goes through the aggressive block flooding path
 	node1.process_local (block, false);
@@ -3950,12 +3950,12 @@ TEST (active_difficulty, recalculate_work)
 	nano::keypair key1;
 	ASSERT_EQ (node1.network_params.network.publish_thresholds.epoch_2, node1.active.active_difficulty ());
 	auto send1 = nano::send_block_builder ()
-	             .previous (genesis.hash ())
-	             .destination (key1.pub)
-	             .balance (0)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key1.pub)
+				 .balance (0)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	auto multiplier1 = nano::difficulty::to_multiplier (send1->difficulty (), node1.network_params.network.publish_thresholds.epoch_2);
 	// Process as local block
 	node1.process_active (send1);
@@ -3995,36 +3995,36 @@ TEST (node, rollback_vote_self)
 	nano::keypair key;
 	auto weight = node.online_reps.delta ();
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::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))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::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))
+				 .build_shared ();
 	auto open = builder.make_block ()
-	            .account (key.pub)
-	            .previous (0)
-	            .representative (key.pub)
-	            .link (send1->hash ())
-	            .balance (weight)
-	            .sign (key.prv, key.pub)
-	            .work (*system.work.generate (key.pub))
-	            .build_shared ();
+				.account (key.pub)
+				.previous (0)
+				.representative (key.pub)
+				.link (send1->hash ())
+				.balance (weight)
+				.sign (key.prv, key.pub)
+				.work (*system.work.generate (key.pub))
+				.build_shared ();
 	auto send2 = builder.make_block ()
-	             .from (*send1)
-	             .previous (send1->hash ())
-	             .balance (send1->balance ().number () - 1)
-	             .link (nano::dev_genesis_key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send1->hash ()))
-	             .build_shared ();
+				 .from (*send1)
+				 .previous (send1->hash ())
+				 .balance (send1->balance ().number () - 1)
+				 .link (nano::dev_genesis_key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send1->hash ()))
+				 .build_shared ();
 	auto fork = builder.make_block ()
-	            .from (*send2)
-	            .balance (send2->balance ().number () - 2)
-	            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	            .build_shared ();
+				.from (*send2)
+				.balance (send2->balance ().number () - 2)
+				.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				.build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.process (*send1).code);
 	ASSERT_EQ (nano::process_result::progress, node.process (*open).code);
 	// Confirm blocks to allow voting
@@ -4088,127 +4088,127 @@ TEST (node, dependency_graph)
 
 	// Send to key1
 	auto gen_send1 = builder.make_block ()
-	                 .account (nano::dev_genesis_key.pub)
-	                 .previous (nano::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))
-	                 .build_shared ();
+					 .account (nano::dev_genesis_key.pub)
+					 .previous (nano::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))
+					 .build_shared ();
 	// Receive from genesis
 	auto key1_open = builder.make_block ()
-	                 .account (key1.pub)
-	                 .previous (0)
-	                 .representative (key1.pub)
-	                 .link (gen_send1->hash ())
-	                 .balance (1)
-	                 .sign (key1.prv, key1.pub)
-	                 .work (*system.work.generate (key1.pub))
-	                 .build ();
+					 .account (key1.pub)
+					 .previous (0)
+					 .representative (key1.pub)
+					 .link (gen_send1->hash ())
+					 .balance (1)
+					 .sign (key1.prv, key1.pub)
+					 .work (*system.work.generate (key1.pub))
+					 .build ();
 	// Send to genesis
 	auto key1_send1 = builder.make_block ()
-	                  .account (key1.pub)
-	                  .previous (key1_open->hash ())
-	                  .representative (key1.pub)
-	                  .link (nano::dev_genesis_key.pub)
-	                  .balance (0)
-	                  .sign (key1.prv, key1.pub)
-	                  .work (*system.work.generate (key1_open->hash ()))
-	                  .build ();
+					  .account (key1.pub)
+					  .previous (key1_open->hash ())
+					  .representative (key1.pub)
+					  .link (nano::dev_genesis_key.pub)
+					  .balance (0)
+					  .sign (key1.prv, key1.pub)
+					  .work (*system.work.generate (key1_open->hash ()))
+					  .build ();
 	// Receive from key1
 	auto gen_receive = builder.make_block ()
-	                   .from (*gen_send1)
-	                   .previous (gen_send1->hash ())
-	                   .link (key1_send1->hash ())
-	                   .balance (nano::genesis_amount)
-	                   .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                   .work (*system.work.generate (gen_send1->hash ()))
-	                   .build ();
+					   .from (*gen_send1)
+					   .previous (gen_send1->hash ())
+					   .link (key1_send1->hash ())
+					   .balance (nano::genesis_amount)
+					   .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					   .work (*system.work.generate (gen_send1->hash ()))
+					   .build ();
 	// Send to key2
 	auto gen_send2 = builder.make_block ()
-	                 .from (*gen_receive)
-	                 .previous (gen_receive->hash ())
-	                 .link (key2.pub)
-	                 .balance (gen_receive->balance ().number () - 2)
-	                 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                 .work (*system.work.generate (gen_receive->hash ()))
-	                 .build ();
+					 .from (*gen_receive)
+					 .previous (gen_receive->hash ())
+					 .link (key2.pub)
+					 .balance (gen_receive->balance ().number () - 2)
+					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					 .work (*system.work.generate (gen_receive->hash ()))
+					 .build ();
 	// Receive from genesis
 	auto key2_open = builder.make_block ()
-	                 .account (key2.pub)
-	                 .previous (0)
-	                 .representative (key2.pub)
-	                 .link (gen_send2->hash ())
-	                 .balance (2)
-	                 .sign (key2.prv, key2.pub)
-	                 .work (*system.work.generate (key2.pub))
-	                 .build ();
+					 .account (key2.pub)
+					 .previous (0)
+					 .representative (key2.pub)
+					 .link (gen_send2->hash ())
+					 .balance (2)
+					 .sign (key2.prv, key2.pub)
+					 .work (*system.work.generate (key2.pub))
+					 .build ();
 	// Send to key3
 	auto key2_send1 = builder.make_block ()
-	                  .account (key2.pub)
-	                  .previous (key2_open->hash ())
-	                  .representative (key2.pub)
-	                  .link (key3.pub)
-	                  .balance (1)
-	                  .sign (key2.prv, key2.pub)
-	                  .work (*system.work.generate (key2_open->hash ()))
-	                  .build ();
+					  .account (key2.pub)
+					  .previous (key2_open->hash ())
+					  .representative (key2.pub)
+					  .link (key3.pub)
+					  .balance (1)
+					  .sign (key2.prv, key2.pub)
+					  .work (*system.work.generate (key2_open->hash ()))
+					  .build ();
 	// Receive from key2
 	auto key3_open = builder.make_block ()
-	                 .account (key3.pub)
-	                 .previous (0)
-	                 .representative (key3.pub)
-	                 .link (key2_send1->hash ())
-	                 .balance (1)
-	                 .sign (key3.prv, key3.pub)
-	                 .work (*system.work.generate (key3.pub))
-	                 .build ();
+					 .account (key3.pub)
+					 .previous (0)
+					 .representative (key3.pub)
+					 .link (key2_send1->hash ())
+					 .balance (1)
+					 .sign (key3.prv, key3.pub)
+					 .work (*system.work.generate (key3.pub))
+					 .build ();
 	// Send to key1
 	auto key2_send2 = builder.make_block ()
-	                  .from (*key2_send1)
-	                  .previous (key2_send1->hash ())
-	                  .link (key1.pub)
-	                  .balance (key2_send1->balance ().number () - 1)
-	                  .sign (key2.prv, key2.pub)
-	                  .work (*system.work.generate (key2_send1->hash ()))
-	                  .build ();
+					  .from (*key2_send1)
+					  .previous (key2_send1->hash ())
+					  .link (key1.pub)
+					  .balance (key2_send1->balance ().number () - 1)
+					  .sign (key2.prv, key2.pub)
+					  .work (*system.work.generate (key2_send1->hash ()))
+					  .build ();
 	// Receive from key2
 	auto key1_receive = builder.make_block ()
-	                    .from (*key1_send1)
-	                    .previous (key1_send1->hash ())
-	                    .link (key2_send2->hash ())
-	                    .balance (key1_send1->balance ().number () + 1)
-	                    .sign (key1.prv, key1.pub)
-	                    .work (*system.work.generate (key1_send1->hash ()))
-	                    .build ();
+						.from (*key1_send1)
+						.previous (key1_send1->hash ())
+						.link (key2_send2->hash ())
+						.balance (key1_send1->balance ().number () + 1)
+						.sign (key1.prv, key1.pub)
+						.work (*system.work.generate (key1_send1->hash ()))
+						.build ();
 	// Send to key3
 	auto key1_send2 = builder.make_block ()
-	                  .from (*key1_receive)
-	                  .previous (key1_receive->hash ())
-	                  .link (key3.pub)
-	                  .balance (key1_receive->balance ().number () - 1)
-	                  .sign (key1.prv, key1.pub)
-	                  .work (*system.work.generate (key1_receive->hash ()))
-	                  .build ();
+					  .from (*key1_receive)
+					  .previous (key1_receive->hash ())
+					  .link (key3.pub)
+					  .balance (key1_receive->balance ().number () - 1)
+					  .sign (key1.prv, key1.pub)
+					  .work (*system.work.generate (key1_receive->hash ()))
+					  .build ();
 	// Receive from key1
 	auto key3_receive = builder.make_block ()
-	                    .from (*key3_open)
-	                    .previous (key3_open->hash ())
-	                    .link (key1_send2->hash ())
-	                    .balance (key3_open->balance ().number () + 1)
-	                    .sign (key3.prv, key3.pub)
-	                    .work (*system.work.generate (key3_open->hash ()))
-	                    .build ();
+						.from (*key3_open)
+						.previous (key3_open->hash ())
+						.link (key1_send2->hash ())
+						.balance (key3_open->balance ().number () + 1)
+						.sign (key3.prv, key3.pub)
+						.work (*system.work.generate (key3_open->hash ()))
+						.build ();
 	// Upgrade key3
 	auto key3_epoch = builder.make_block ()
-	                  .from (*key3_receive)
-	                  .previous (key3_receive->hash ())
-	                  .link (node.ledger.epoch_link (nano::epoch::epoch_1))
-	                  .balance (key3_receive->balance ())
-	                  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                  .work (*system.work.generate (key3_receive->hash ()))
-	                  .build ();
+					  .from (*key3_receive)
+					  .previous (key3_receive->hash ())
+					  .link (node.ledger.epoch_link (nano::epoch::epoch_1))
+					  .balance (key3_receive->balance ())
+					  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					  .work (*system.work.generate (key3_receive->hash ()))
+					  .build ();
 
 	ASSERT_EQ (nano::process_result::progress, node.process (*gen_send1).code);
 	ASSERT_EQ (nano::process_result::progress, node.process (*key1_open).code);
@@ -4290,127 +4290,127 @@ TEST (node, dependency_graph_frontier)
 
 	// Send to key1
 	auto gen_send1 = builder.make_block ()
-	                 .account (nano::dev_genesis_key.pub)
-	                 .previous (nano::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))
-	                 .build_shared ();
+					 .account (nano::dev_genesis_key.pub)
+					 .previous (nano::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))
+					 .build_shared ();
 	// Receive from genesis
 	auto key1_open = builder.make_block ()
-	                 .account (key1.pub)
-	                 .previous (0)
-	                 .representative (key1.pub)
-	                 .link (gen_send1->hash ())
-	                 .balance (1)
-	                 .sign (key1.prv, key1.pub)
-	                 .work (*system.work.generate (key1.pub))
-	                 .build ();
+					 .account (key1.pub)
+					 .previous (0)
+					 .representative (key1.pub)
+					 .link (gen_send1->hash ())
+					 .balance (1)
+					 .sign (key1.prv, key1.pub)
+					 .work (*system.work.generate (key1.pub))
+					 .build ();
 	// Send to genesis
 	auto key1_send1 = builder.make_block ()
-	                  .account (key1.pub)
-	                  .previous (key1_open->hash ())
-	                  .representative (key1.pub)
-	                  .link (nano::dev_genesis_key.pub)
-	                  .balance (0)
-	                  .sign (key1.prv, key1.pub)
-	                  .work (*system.work.generate (key1_open->hash ()))
-	                  .build ();
+					  .account (key1.pub)
+					  .previous (key1_open->hash ())
+					  .representative (key1.pub)
+					  .link (nano::dev_genesis_key.pub)
+					  .balance (0)
+					  .sign (key1.prv, key1.pub)
+					  .work (*system.work.generate (key1_open->hash ()))
+					  .build ();
 	// Receive from key1
 	auto gen_receive = builder.make_block ()
-	                   .from (*gen_send1)
-	                   .previous (gen_send1->hash ())
-	                   .link (key1_send1->hash ())
-	                   .balance (nano::genesis_amount)
-	                   .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                   .work (*system.work.generate (gen_send1->hash ()))
-	                   .build ();
+					   .from (*gen_send1)
+					   .previous (gen_send1->hash ())
+					   .link (key1_send1->hash ())
+					   .balance (nano::genesis_amount)
+					   .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					   .work (*system.work.generate (gen_send1->hash ()))
+					   .build ();
 	// Send to key2
 	auto gen_send2 = builder.make_block ()
-	                 .from (*gen_receive)
-	                 .previous (gen_receive->hash ())
-	                 .link (key2.pub)
-	                 .balance (gen_receive->balance ().number () - 2)
-	                 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                 .work (*system.work.generate (gen_receive->hash ()))
-	                 .build ();
+					 .from (*gen_receive)
+					 .previous (gen_receive->hash ())
+					 .link (key2.pub)
+					 .balance (gen_receive->balance ().number () - 2)
+					 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					 .work (*system.work.generate (gen_receive->hash ()))
+					 .build ();
 	// Receive from genesis
 	auto key2_open = builder.make_block ()
-	                 .account (key2.pub)
-	                 .previous (0)
-	                 .representative (key2.pub)
-	                 .link (gen_send2->hash ())
-	                 .balance (2)
-	                 .sign (key2.prv, key2.pub)
-	                 .work (*system.work.generate (key2.pub))
-	                 .build ();
+					 .account (key2.pub)
+					 .previous (0)
+					 .representative (key2.pub)
+					 .link (gen_send2->hash ())
+					 .balance (2)
+					 .sign (key2.prv, key2.pub)
+					 .work (*system.work.generate (key2.pub))
+					 .build ();
 	// Send to key3
 	auto key2_send1 = builder.make_block ()
-	                  .account (key2.pub)
-	                  .previous (key2_open->hash ())
-	                  .representative (key2.pub)
-	                  .link (key3.pub)
-	                  .balance (1)
-	                  .sign (key2.prv, key2.pub)
-	                  .work (*system.work.generate (key2_open->hash ()))
-	                  .build ();
+					  .account (key2.pub)
+					  .previous (key2_open->hash ())
+					  .representative (key2.pub)
+					  .link (key3.pub)
+					  .balance (1)
+					  .sign (key2.prv, key2.pub)
+					  .work (*system.work.generate (key2_open->hash ()))
+					  .build ();
 	// Receive from key2
 	auto key3_open = builder.make_block ()
-	                 .account (key3.pub)
-	                 .previous (0)
-	                 .representative (key3.pub)
-	                 .link (key2_send1->hash ())
-	                 .balance (1)
-	                 .sign (key3.prv, key3.pub)
-	                 .work (*system.work.generate (key3.pub))
-	                 .build ();
+					 .account (key3.pub)
+					 .previous (0)
+					 .representative (key3.pub)
+					 .link (key2_send1->hash ())
+					 .balance (1)
+					 .sign (key3.prv, key3.pub)
+					 .work (*system.work.generate (key3.pub))
+					 .build ();
 	// Send to key1
 	auto key2_send2 = builder.make_block ()
-	                  .from (*key2_send1)
-	                  .previous (key2_send1->hash ())
-	                  .link (key1.pub)
-	                  .balance (key2_send1->balance ().number () - 1)
-	                  .sign (key2.prv, key2.pub)
-	                  .work (*system.work.generate (key2_send1->hash ()))
-	                  .build ();
+					  .from (*key2_send1)
+					  .previous (key2_send1->hash ())
+					  .link (key1.pub)
+					  .balance (key2_send1->balance ().number () - 1)
+					  .sign (key2.prv, key2.pub)
+					  .work (*system.work.generate (key2_send1->hash ()))
+					  .build ();
 	// Receive from key2
 	auto key1_receive = builder.make_block ()
-	                    .from (*key1_send1)
-	                    .previous (key1_send1->hash ())
-	                    .link (key2_send2->hash ())
-	                    .balance (key1_send1->balance ().number () + 1)
-	                    .sign (key1.prv, key1.pub)
-	                    .work (*system.work.generate (key1_send1->hash ()))
-	                    .build ();
+						.from (*key1_send1)
+						.previous (key1_send1->hash ())
+						.link (key2_send2->hash ())
+						.balance (key1_send1->balance ().number () + 1)
+						.sign (key1.prv, key1.pub)
+						.work (*system.work.generate (key1_send1->hash ()))
+						.build ();
 	// Send to key3
 	auto key1_send2 = builder.make_block ()
-	                  .from (*key1_receive)
-	                  .previous (key1_receive->hash ())
-	                  .link (key3.pub)
-	                  .balance (key1_receive->balance ().number () - 1)
-	                  .sign (key1.prv, key1.pub)
-	                  .work (*system.work.generate (key1_receive->hash ()))
-	                  .build ();
+					  .from (*key1_receive)
+					  .previous (key1_receive->hash ())
+					  .link (key3.pub)
+					  .balance (key1_receive->balance ().number () - 1)
+					  .sign (key1.prv, key1.pub)
+					  .work (*system.work.generate (key1_receive->hash ()))
+					  .build ();
 	// Receive from key1
 	auto key3_receive = builder.make_block ()
-	                    .from (*key3_open)
-	                    .previous (key3_open->hash ())
-	                    .link (key1_send2->hash ())
-	                    .balance (key3_open->balance ().number () + 1)
-	                    .sign (key3.prv, key3.pub)
-	                    .work (*system.work.generate (key3_open->hash ()))
-	                    .build ();
+						.from (*key3_open)
+						.previous (key3_open->hash ())
+						.link (key1_send2->hash ())
+						.balance (key3_open->balance ().number () + 1)
+						.sign (key3.prv, key3.pub)
+						.work (*system.work.generate (key3_open->hash ()))
+						.build ();
 	// Upgrade key3
 	auto key3_epoch = builder.make_block ()
-	                  .from (*key3_receive)
-	                  .previous (key3_receive->hash ())
-	                  .link (node1.ledger.epoch_link (nano::epoch::epoch_1))
-	                  .balance (key3_receive->balance ())
-	                  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                  .work (*system.work.generate (key3_receive->hash ()))
-	                  .build ();
+					  .from (*key3_receive)
+					  .previous (key3_receive->hash ())
+					  .link (node1.ledger.epoch_link (nano::epoch::epoch_1))
+					  .balance (key3_receive->balance ())
+					  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					  .work (*system.work.generate (key3_receive->hash ()))
+					  .build ();
 
 	for (auto const & node : system.nodes)
 	{
@@ -4453,44 +4453,44 @@ TEST (node, deferred_dependent_elections)
 	nano::state_block_builder builder;
 	nano::keypair key;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::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))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::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))
+				 .build_shared ();
 	auto open = builder.make_block ()
-	            .account (key.pub)
-	            .previous (0)
-	            .representative (key.pub)
-	            .link (send1->hash ())
-	            .balance (1)
-	            .sign (key.prv, key.pub)
-	            .work (*system.work.generate (key.pub))
-	            .build_shared ();
+				.account (key.pub)
+				.previous (0)
+				.representative (key.pub)
+				.link (send1->hash ())
+				.balance (1)
+				.sign (key.prv, key.pub)
+				.work (*system.work.generate (key.pub))
+				.build_shared ();
 	auto send2 = builder.make_block ()
-	             .from (*send1)
-	             .previous (send1->hash ())
-	             .balance (send1->balance ().number () - 1)
-	             .link (key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send1->hash ()))
-	             .build_shared ();
+				 .from (*send1)
+				 .previous (send1->hash ())
+				 .balance (send1->balance ().number () - 1)
+				 .link (key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send1->hash ()))
+				 .build_shared ();
 	auto receive = builder.make_block ()
-	               .from (*open)
-	               .previous (open->hash ())
-	               .link (send2->hash ())
-	               .balance (2)
-	               .sign (key.prv, key.pub)
-	               .work (*system.work.generate (open->hash ()))
-	               .build_shared ();
+				   .from (*open)
+				   .previous (open->hash ())
+				   .link (send2->hash ())
+				   .balance (2)
+				   .sign (key.prv, key.pub)
+				   .work (*system.work.generate (open->hash ()))
+				   .build_shared ();
 	auto fork = builder.make_block ()
-	            .from (*receive)
-	            .representative (nano::dev_genesis_key.pub) // was key.pub
-	            .sign (key.prv, key.pub)
-	            .build_shared ();
+				.from (*receive)
+				.representative (nano::dev_genesis_key.pub) // was key.pub
+				.sign (key.prv, key.pub)
+				.build_shared ();
 	node.process_local (send1);
 	node.block_processor.flush ();
 	node.scheduler.flush ();
@@ -4635,19 +4635,19 @@ TEST (node, pruning_automatic)
 	nano::genesis genesis;
 	nano::keypair key1;
 	auto send1 = nano::send_block_builder ()
-	             .previous (genesis.hash ())
-	             .destination (key1.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key1.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	auto send2 = nano::send_block_builder ()
-	             .previous (send1->hash ())
-	             .destination (key1.pub)
-	             .balance (0)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send1->hash ()))
-	             .build_shared ();
+				 .previous (send1->hash ())
+				 .destination (key1.pub)
+				 .balance (0)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send1->hash ()))
+				 .build_shared ();
 	// Process as local blocks
 	node1.process_active (send1);
 	node1.process_active (send2);
@@ -4689,19 +4689,19 @@ TEST (node, pruning_age)
 	nano::genesis genesis;
 	nano::keypair key1;
 	auto send1 = nano::send_block_builder ()
-	             .previous (genesis.hash ())
-	             .destination (key1.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key1.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	auto send2 = nano::send_block_builder ()
-	             .previous (send1->hash ())
-	             .destination (key1.pub)
-	             .balance (0)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send1->hash ()))
-	             .build_shared ();
+				 .previous (send1->hash ())
+				 .destination (key1.pub)
+				 .balance (0)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send1->hash ()))
+				 .build_shared ();
 	// Process as local blocks
 	node1.process_active (send1);
 	node1.process_active (send2);
@@ -4747,19 +4747,19 @@ TEST (node, pruning_depth)
 	nano::genesis genesis;
 	nano::keypair key1;
 	auto send1 = nano::send_block_builder ()
-	             .previous (genesis.hash ())
-	             .destination (key1.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (genesis.hash ()))
-	             .build_shared ();
+				 .previous (genesis.hash ())
+				 .destination (key1.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (genesis.hash ()))
+				 .build_shared ();
 	auto send2 = nano::send_block_builder ()
-	             .previous (send1->hash ())
-	             .destination (key1.pub)
-	             .balance (0)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send1->hash ()))
-	             .build_shared ();
+				 .previous (send1->hash ())
+				 .destination (key1.pub)
+				 .balance (0)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send1->hash ()))
+				 .build_shared ();
 	// Process as local blocks
 	node1.process_active (send1);
 	node1.process_active (send2);
diff --git a/nano/core_test/peer_container.cpp b/nano/core_test/peer_container.cpp
index e9871b5378..9914ab3e9a 100644
--- a/nano/core_test/peer_container.cpp
+++ b/nano/core_test/peer_container.cpp
@@ -20,8 +20,8 @@ TEST (peer_container, no_recontact)
 	auto observed_disconnect (false);
 	nano::endpoint endpoint1 (boost::asio::ip::address_v6::loopback (), 10000);
 	ASSERT_EQ (0, network.size ());
-	network.channel_observer = [&observed_peer](std::shared_ptr<nano::transport::channel> const &) { ++observed_peer; };
-	node1.network.disconnect_observer = [&observed_disconnect]() { observed_disconnect = true; };
+	network.channel_observer = [&observed_peer] (std::shared_ptr<nano::transport::channel> const &) { ++observed_peer; };
+	node1.network.disconnect_observer = [&observed_disconnect] () { observed_disconnect = true; };
 	auto channel (network.udp_channels.insert (endpoint1, node1.network_params.protocol.protocol_version));
 	ASSERT_EQ (1, network.size ());
 	ASSERT_EQ (channel, network.udp_channels.insert (endpoint1, node1.network_params.protocol.protocol_version));
@@ -61,12 +61,12 @@ TEST (peer_container, split)
 	nano::endpoint endpoint2 (boost::asio::ip::address_v6::loopback (), 101);
 	auto channel1 (node1.network.udp_channels.insert (endpoint1, 0));
 	ASSERT_NE (nullptr, channel1);
-	node1.network.udp_channels.modify (channel1, [&now](auto channel) {
+	node1.network.udp_channels.modify (channel1, [&now] (auto channel) {
 		channel->set_last_packet_received (now - std::chrono::seconds (1));
 	});
 	auto channel2 (node1.network.udp_channels.insert (endpoint2, 0));
 	ASSERT_NE (nullptr, channel2);
-	node1.network.udp_channels.modify (channel2, [&now](auto channel) {
+	node1.network.udp_channels.modify (channel2, [&now] (auto channel) {
 		channel->set_last_packet_received (now + std::chrono::seconds (1));
 	});
 	ASSERT_EQ (2, node1.network.size ());
@@ -84,7 +84,7 @@ TEST (channels, fill_random_clear)
 	std::array<nano::endpoint, 8> target;
 	std::fill (target.begin (), target.end (), nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000));
 	system.nodes[0]->network.random_fill (target);
-	ASSERT_TRUE (std::all_of (target.begin (), target.end (), [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::any (), 0); }));
+	ASSERT_TRUE (std::all_of (target.begin (), target.end (), [] (nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::any (), 0); }));
 }
 
 TEST (channels, fill_random_full)
@@ -97,7 +97,7 @@ TEST (channels, fill_random_full)
 	std::array<nano::endpoint, 8> target;
 	std::fill (target.begin (), target.end (), nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000));
 	system.nodes[0]->network.random_fill (target);
-	ASSERT_TRUE (std::none_of (target.begin (), target.end (), [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000); }));
+	ASSERT_TRUE (std::none_of (target.begin (), target.end (), [] (nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000); }));
 }
 
 TEST (channels, fill_random_part)
@@ -111,9 +111,9 @@ TEST (channels, fill_random_part)
 	}
 	std::fill (target.begin (), target.end (), nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000));
 	system.nodes[0]->network.random_fill (target);
-	ASSERT_TRUE (std::none_of (target.begin (), target.begin () + half, [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000); }));
-	ASSERT_TRUE (std::none_of (target.begin (), target.begin () + half, [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 0); }));
-	ASSERT_TRUE (std::all_of (target.begin () + half, target.end (), [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::any (), 0); }));
+	ASSERT_TRUE (std::none_of (target.begin (), target.begin () + half, [] (nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000); }));
+	ASSERT_TRUE (std::none_of (target.begin (), target.begin () + half, [] (nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 0); }));
+	ASSERT_TRUE (std::all_of (target.begin () + half, target.end (), [] (nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::any (), 0); }));
 }
 
 TEST (peer_container, list_fanout)
@@ -125,7 +125,7 @@ TEST (peer_container, list_fanout)
 	ASSERT_EQ (0, node.network.fanout ());
 	auto list1 (node.network.list (node.network.fanout ()));
 	ASSERT_TRUE (list1.empty ());
-	auto add_peer = [&node](const uint16_t port_a) {
+	auto add_peer = [&node] (const uint16_t port_a) {
 		ASSERT_NE (nullptr, node.network.udp_channels.insert (nano::endpoint (boost::asio::ip::address_v6::loopback (), port_a), node.network_params.protocol.protocol_version));
 	};
 	add_peer (9998);
diff --git a/nano/core_test/processor_service.cpp b/nano/core_test/processor_service.cpp
index ae79ab2073..913eba5b03 100644
--- a/nano/core_test/processor_service.cpp
+++ b/nano/core_test/processor_service.cpp
@@ -7,7 +7,6 @@
 
 #include <gtest/gtest.h>
 
-
 TEST (processor_service, bad_send_signature)
 {
 	nano::logger_mt logger;
diff --git a/nano/core_test/request_aggregator.cpp b/nano/core_test/request_aggregator.cpp
index a910b5cd79..28758cf998 100644
--- a/nano/core_test/request_aggregator.cpp
+++ b/nano/core_test/request_aggregator.cpp
@@ -53,37 +53,37 @@ TEST (request_aggregator, one_update)
 	system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
 	nano::keypair key1;
 	auto send1 = nano::state_block_builder ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - nano::Gxrb_ratio)
-	             .link (nano::dev_genesis_key.pub)
-	             .link (key1.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node.work_generate_blocking (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - nano::Gxrb_ratio)
+				 .link (nano::dev_genesis_key.pub)
+				 .link (key1.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node.work_generate_blocking (genesis.hash ()))
+				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
 	node.confirmation_height_processor.add (send1);
 	ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ()));
 	auto send2 = nano::state_block_builder ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send1->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
-	             .link (nano::dev_genesis_key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node.work_generate_blocking (send1->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send1->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
+				 .link (nano::dev_genesis_key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node.work_generate_blocking (send1->hash ()))
+				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
 	auto receive1 = nano::state_block_builder ()
-	                .account (key1.pub)
-	                .previous (0)
-	                .representative (nano::dev_genesis_key.pub)
-	                .balance (nano::Gxrb_ratio)
-	                .link (send1->hash ())
-	                .sign (key1.prv, key1.pub)
-	                .work (*node.work_generate_blocking (key1.pub))
-	                .build_shared ();
+					.account (key1.pub)
+					.previous (0)
+					.representative (nano::dev_genesis_key.pub)
+					.balance (nano::Gxrb_ratio)
+					.link (send1->hash ())
+					.sign (key1.prv, key1.pub)
+					.work (*node.work_generate_blocking (key1.pub))
+					.build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code);
 	std::vector<std::pair<nano::block_hash, nano::root>> request;
 	request.emplace_back (send2->hash (), send2->root ());
@@ -120,35 +120,35 @@ TEST (request_aggregator, two)
 	nano::keypair key1;
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (genesis.hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 1)
-	             .link (key1.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node.work_generate_blocking (genesis.hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (genesis.hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 1)
+				 .link (key1.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node.work_generate_blocking (genesis.hash ()))
+				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
 	node.confirmation_height_processor.add (send1);
 	ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ()));
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (send1->hash ())
-	             .representative (nano::dev_genesis_key.pub)
-	             .balance (nano::genesis_amount - 2)
-	             .link (nano::dev_genesis_key.pub)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*node.work_generate_blocking (send1->hash ()))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (send1->hash ())
+				 .representative (nano::dev_genesis_key.pub)
+				 .balance (nano::genesis_amount - 2)
+				 .link (nano::dev_genesis_key.pub)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*node.work_generate_blocking (send1->hash ()))
+				 .build_shared ();
 	auto receive1 = builder.make_block ()
-	                .account (key1.pub)
-	                .previous (0)
-	                .representative (nano::dev_genesis_key.pub)
-	                .balance (1)
-	                .link (send1->hash ())
-	                .sign (key1.prv, key1.pub)
-	                .work (*node.work_generate_blocking (key1.pub))
-	                .build_shared ();
+					.account (key1.pub)
+					.previous (0)
+					.representative (nano::dev_genesis_key.pub)
+					.balance (1)
+					.link (send1->hash ())
+					.sign (key1.prv, key1.pub)
+					.work (*node.work_generate_blocking (key1.pub))
+					.build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
 	ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code);
 	std::vector<std::pair<nano::block_hash, nano::root>> request;
@@ -234,15 +234,15 @@ TEST (request_aggregator, split)
 	{
 		nano::block_builder builder;
 		blocks.push_back (builder
-		                  .state ()
-		                  .account (nano::dev_genesis_key.pub)
-		                  .previous (previous)
-		                  .representative (nano::dev_genesis_key.pub)
-		                  .balance (nano::genesis_amount - (i + 1))
-		                  .link (nano::dev_genesis_key.pub)
-		                  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		                  .work (*system.work.generate (previous))
-		                  .build ());
+						  .state ()
+						  .account (nano::dev_genesis_key.pub)
+						  .previous (previous)
+						  .representative (nano::dev_genesis_key.pub)
+						  .balance (nano::genesis_amount - (i + 1))
+						  .link (nano::dev_genesis_key.pub)
+						  .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+						  .work (*system.work.generate (previous))
+						  .build ());
 		auto const & block = blocks.back ();
 		previous = block->hash ();
 		ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *block).code);
@@ -374,21 +374,21 @@ TEST (request_aggregator, cannot_vote)
 	nano::genesis genesis;
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::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))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::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))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .from (*send1)
-	             .previous (send1->hash ())
-	             .balance (send1->balance ().number () - 1)
-	             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	             .work (*system.work.generate (send1->hash ()))
-	             .build_shared ();
+				 .from (*send1)
+				 .previous (send1->hash ())
+				 .balance (send1->balance ().number () - 1)
+				 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+				 .work (*system.work.generate (send1->hash ()))
+				 .build_shared ();
 	ASSERT_EQ (nano::process_result::progress, node.process (*send1).code);
 	ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
 	system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
diff --git a/nano/core_test/signing.cpp b/nano/core_test/signing.cpp
index dba108be9a..3408d7613d 100644
--- a/nano/core_test/signing.cpp
+++ b/nano/core_test/signing.cpp
@@ -38,7 +38,7 @@ TEST (signature_checker, bulk_single_thread)
 	}
 	nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () };
 	checker.verify (check);
-	bool all_valid = std::all_of (verifications.cbegin (), verifications.cend (), [](auto verification) { return verification == 1; });
+	bool all_valid = std::all_of (verifications.cbegin (), verifications.cend (), [] (auto verification) { return verification == 1; });
 	ASSERT_TRUE (all_valid);
 }
 
@@ -46,7 +46,7 @@ TEST (signature_checker, many_multi_threaded)
 {
 	nano::signature_checker checker (4);
 
-	auto signature_checker_work_func = [&checker]() {
+	auto signature_checker_work_func = [&checker] () {
 		nano::keypair key;
 		nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0);
 		auto block_hash = block.hash ();
@@ -97,7 +97,7 @@ TEST (signature_checker, many_multi_threaded)
 			checker.verify (signature_checker_sets[i]);
 
 			// Confirm all but last are valid
-			auto all_valid = std::all_of (verifications[i].cbegin (), verifications[i].cend () - 1, [](auto verification) { return verification == 1; });
+			auto all_valid = std::all_of (verifications[i].cbegin (), verifications[i].cend () - 1, [] (auto verification) { return verification == 1; });
 			ASSERT_TRUE (all_valid);
 			ASSERT_EQ (verifications[i][last_signature_index], 0);
 		}
@@ -114,7 +114,7 @@ TEST (signature_checker, one)
 {
 	nano::signature_checker checker (0);
 
-	auto verify_block = [&checker](auto & block, auto result) {
+	auto verify_block = [&checker] (auto & block, auto result) {
 		std::vector<nano::uint256_union> hashes;
 		std::vector<unsigned char const *> messages;
 		std::vector<size_t> lengths;
@@ -152,7 +152,7 @@ TEST (signature_checker, boundary_checks)
 {
 	// sizes container must be in incrementing order
 	std::vector<size_t> sizes{ 0, 1 };
-	auto add_boundary = [&sizes](size_t boundary) {
+	auto add_boundary = [&sizes] (size_t boundary) {
 		sizes.insert (sizes.end (), { boundary - 1, boundary, boundary + 1 });
 	};
 
@@ -194,7 +194,7 @@ TEST (signature_checker, boundary_checks)
 		}
 		nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () };
 		checker.verify (check);
-		bool all_valid = std::all_of (verifications.cbegin (), verifications.cend (), [](auto verification) { return verification == 1; });
+		bool all_valid = std::all_of (verifications.cbegin (), verifications.cend (), [] (auto verification) { return verification == 1; });
 		ASSERT_TRUE (all_valid);
 		last_size = size;
 	}
diff --git a/nano/core_test/socket.cpp b/nano/core_test/socket.cpp
index d1eb05d93d..eedab3997c 100644
--- a/nano/core_test/socket.cpp
+++ b/nano/core_test/socket.cpp
@@ -18,7 +18,7 @@ TEST (socket, drop_policy)
 
 	std::vector<std::shared_ptr<nano::socket>> connections;
 
-	auto func = [&](size_t total_message_count, nano::buffer_drop_policy drop_policy) {
+	auto func = [&] (size_t total_message_count, nano::buffer_drop_policy drop_policy) {
 		auto server_port (nano::get_available_port ());
 		boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v6::any (), server_port);
 
@@ -28,7 +28,7 @@ TEST (socket, drop_policy)
 		ASSERT_FALSE (ec);
 
 		// Accept connection, but don't read so the writer will drop.
-		server_socket->on_connection ([&connections](std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) {
+		server_socket->on_connection ([&connections] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) {
 			connections.push_back (new_connection);
 			return true;
 		});
@@ -38,12 +38,12 @@ TEST (socket, drop_policy)
 		nano::util::counted_completion write_completion (static_cast<unsigned> (total_message_count));
 
 		client->async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v6::loopback (), server_port),
-		[&channel, total_message_count, node, &write_completion, &drop_policy, client](boost::system::error_code const & ec_a) mutable {
+		[&channel, total_message_count, node, &write_completion, &drop_policy, client] (boost::system::error_code const & ec_a) mutable {
 			for (int i = 0; i < total_message_count; i++)
 			{
 				std::vector<uint8_t> buff (1);
 				channel.send_buffer (
-				nano::shared_const_buffer (std::move (buff)), [&write_completion, client](boost::system::error_code const & ec, size_t size_a) mutable {
+				nano::shared_const_buffer (std::move (buff)), [&write_completion, client] (boost::system::error_code const & ec, size_t size_a) mutable {
 					client.reset ();
 					write_completion.increment ();
 				},
@@ -88,7 +88,7 @@ TEST (socket, concurrent_writes)
 
 	// We're expecting client_count*4 messages
 	nano::util::counted_completion read_count_completion (total_message_count);
-	std::function<void(std::shared_ptr<nano::socket> const &)> reader = [&read_count_completion, &total_message_count, &reader](std::shared_ptr<nano::socket> const & socket_a) {
+	std::function<void (std::shared_ptr<nano::socket> const &)> reader = [&read_count_completion, &total_message_count, &reader] (std::shared_ptr<nano::socket> const & socket_a) {
 		auto buff (std::make_shared<std::vector<uint8_t>> ());
 		buff->resize (1);
 #ifndef _WIN32
@@ -100,7 +100,7 @@ TEST (socket, concurrent_writes)
 #endif
 #endif
 #endif
-		socket_a->async_read (buff, 1, [&read_count_completion, &reader, &total_message_count, socket_a, buff](boost::system::error_code const & ec, size_t size_a) {
+		socket_a->async_read (buff, 1, [&read_count_completion, &reader, &total_message_count, socket_a, buff] (boost::system::error_code const & ec, size_t size_a) {
 			if (!ec)
 			{
 				if (read_count_completion.increment () < total_message_count)
@@ -127,7 +127,7 @@ TEST (socket, concurrent_writes)
 	std::vector<std::shared_ptr<nano::socket>> connections;
 
 	// On every new connection, start reading data
-	server_socket->on_connection ([&connections, &reader](std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) {
+	server_socket->on_connection ([&connections, &reader] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) {
 		if (ec_a)
 		{
 			std::cerr << "on_connection: " << ec_a.message () << std::endl;
@@ -148,7 +148,7 @@ TEST (socket, concurrent_writes)
 		auto client = std::make_shared<nano::socket> (*node, boost::none);
 		clients.push_back (client);
 		client->async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), 25000),
-		[&connection_count_completion](boost::system::error_code const & ec_a) {
+		[&connection_count_completion] (boost::system::error_code const & ec_a) {
 			if (ec_a)
 			{
 				std::cerr << "async_connect: " << ec_a.message () << std::endl;
@@ -175,7 +175,7 @@ TEST (socket, concurrent_writes)
 #endif
 #endif
 #endif
-		client_threads.emplace_back ([&client, &message_count]() {
+		client_threads.emplace_back ([&client, &message_count] () {
 			for (int i = 0; i < message_count; i++)
 			{
 				std::vector<uint8_t> buff;
diff --git a/nano/core_test/telemetry.cpp b/nano/core_test/telemetry.cpp
index bd365a71cc..669e4fc85f 100644
--- a/nano/core_test/telemetry.cpp
+++ b/nano/core_test/telemetry.cpp
@@ -242,7 +242,7 @@ TEST (telemetry, basic)
 	auto channel = node_client->network.find_channel (node_server->network.endpoint ());
 	{
 		std::atomic<bool> done{ false };
-		node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &server_endpoint, &telemetry_data](nano::telemetry_data_response const & response_a) {
+		node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &server_endpoint, &telemetry_data] (nano::telemetry_data_response const & response_a) {
 			ASSERT_FALSE (response_a.error);
 			ASSERT_EQ (server_endpoint, response_a.endpoint);
 			telemetry_data = response_a.telemetry_data;
@@ -258,7 +258,7 @@ TEST (telemetry, basic)
 	// Call again straight away. It should use the cache
 	{
 		std::atomic<bool> done{ false };
-		node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &telemetry_data](nano::telemetry_data_response const & response_a) {
+		node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &telemetry_data] (nano::telemetry_data_response const & response_a) {
 			ASSERT_EQ (telemetry_data, response_a.telemetry_data);
 			ASSERT_FALSE (response_a.error);
 			done = true;
@@ -271,7 +271,7 @@ TEST (telemetry, basic)
 	std::this_thread::sleep_for (nano::telemetry_cache_cutoffs::dev);
 
 	std::atomic<bool> done{ false };
-	node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &telemetry_data](nano::telemetry_data_response const & response_a) {
+	node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &telemetry_data] (nano::telemetry_data_response const & response_a) {
 		ASSERT_NE (telemetry_data, response_a.telemetry_data);
 		ASSERT_FALSE (response_a.error);
 		done = true;
@@ -303,7 +303,7 @@ TEST (telemetry, over_udp)
 
 	std::atomic<bool> done{ false };
 	auto channel = node_client->network.find_channel (node_server->network.endpoint ());
-	node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &node_server](nano::telemetry_data_response const & response_a) {
+	node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &node_server] (nano::telemetry_data_response const & response_a) {
 		ASSERT_FALSE (response_a.error);
 		nano::compare_default_telemetry_response_data (response_a.telemetry_data, node_server->network_params, node_server->config.bandwidth_limit, node_server->active.active_difficulty (), node_server->node_id);
 		done = true;
@@ -330,7 +330,7 @@ TEST (telemetry, invalid_channel)
 	auto node_server = system.nodes.back ();
 
 	std::atomic<bool> done{ false };
-	node_client->telemetry->get_metrics_single_peer_async (nullptr, [&done](nano::telemetry_data_response const & response_a) {
+	node_client->telemetry->get_metrics_single_peer_async (nullptr, [&done] (nano::telemetry_data_response const & response_a) {
 		ASSERT_TRUE (response_a.error);
 		done = true;
 	});
@@ -349,9 +349,9 @@ TEST (telemetry, blocking_request)
 
 	// Request telemetry metrics
 	std::atomic<bool> done{ false };
-	std::function<void()> call_system_poll;
+	std::function<void ()> call_system_poll;
 	std::promise<void> promise;
-	call_system_poll = [&call_system_poll, &workers = node_client->workers, &done, &system, &promise]() {
+	call_system_poll = [&call_system_poll, &workers = node_client->workers, &done, &system, &promise] () {
 		if (!done)
 		{
 			ASSERT_NO_ERROR (system.poll ());
@@ -392,7 +392,7 @@ TEST (telemetry, disconnects)
 	ASSERT_TRUE (channel);
 
 	std::atomic<bool> done{ false };
-	node_client->telemetry->get_metrics_single_peer_async (channel, [&done](nano::telemetry_data_response const & response_a) {
+	node_client->telemetry->get_metrics_single_peer_async (channel, [&done] (nano::telemetry_data_response const & response_a) {
 		ASSERT_TRUE (response_a.error);
 		done = true;
 	});
@@ -414,7 +414,7 @@ TEST (telemetry, dos_tcp)
 
 	nano::telemetry_req message;
 	auto channel = node_client->network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node_server->network.endpoint ()));
-	channel->send (message, [](boost::system::error_code const & ec, size_t size_a) {
+	channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) {
 		ASSERT_FALSE (ec);
 	});
 
@@ -423,7 +423,7 @@ TEST (telemetry, dos_tcp)
 	auto orig = std::chrono::steady_clock::now ();
 	for (int i = 0; i < 10; ++i)
 	{
-		channel->send (message, [](boost::system::error_code const & ec, size_t size_a) {
+		channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) {
 			ASSERT_FALSE (ec);
 		});
 	}
@@ -457,7 +457,7 @@ TEST (telemetry, dos_udp)
 
 	nano::telemetry_req message;
 	auto channel (node_client->network.udp_channels.create (node_server->network.endpoint ()));
-	channel->send (message, [](boost::system::error_code const & ec, size_t size_a) {
+	channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) {
 		ASSERT_FALSE (ec);
 	});
 
@@ -466,7 +466,7 @@ TEST (telemetry, dos_udp)
 	auto orig = std::chrono::steady_clock::now ();
 	for (int i = 0; i < 10; ++i)
 	{
-		channel->send (message, [](boost::system::error_code const & ec, size_t size_a) {
+		channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) {
 			ASSERT_FALSE (ec);
 		});
 	}
@@ -501,7 +501,7 @@ TEST (telemetry, disable_metrics)
 	ASSERT_TRUE (channel);
 
 	std::atomic<bool> done{ false };
-	node_client->telemetry->get_metrics_single_peer_async (channel, [&done](nano::telemetry_data_response const & response_a) {
+	node_client->telemetry->get_metrics_single_peer_async (channel, [&done] (nano::telemetry_data_response const & response_a) {
 		ASSERT_TRUE (response_a.error);
 		done = true;
 	});
@@ -511,7 +511,7 @@ TEST (telemetry, disable_metrics)
 	// It should still be able to receive metrics though
 	done = false;
 	auto channel1 = node_server->network.find_channel (node_client->network.endpoint ());
-	node_server->telemetry->get_metrics_single_peer_async (channel1, [&done, node_client](nano::telemetry_data_response const & response_a) {
+	node_server->telemetry->get_metrics_single_peer_async (channel1, [&done, node_client] (nano::telemetry_data_response const & response_a) {
 		ASSERT_FALSE (response_a.error);
 		nano::compare_default_telemetry_response_data (response_a.telemetry_data, node_client->network_params, node_client->config.bandwidth_limit, node_client->active.active_difficulty (), node_client->node_id);
 		done = true;
@@ -536,7 +536,7 @@ TEST (telemetry, max_possible_size)
 	wait_peer_connections (system);
 
 	auto channel = node_client->network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node_server->network.endpoint ()));
-	channel->send (message, [](boost::system::error_code const & ec, size_t size_a) {
+	channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) {
 		ASSERT_FALSE (ec);
 	});
 
@@ -596,11 +596,11 @@ TEST (telemetry, remove_peer_different_genesis_udp)
 	std::atomic<bool> done0{ false };
 	std::atomic<bool> done1{ false };
 
-	node0->telemetry->get_metrics_single_peer_async (channel1, [&done0](nano::telemetry_data_response const & response_a) {
+	node0->telemetry->get_metrics_single_peer_async (channel1, [&done0] (nano::telemetry_data_response const & response_a) {
 		done0 = true;
 	});
 
-	node1->telemetry->get_metrics_single_peer_async (channel0, [&done1](nano::telemetry_data_response const & response_a) {
+	node1->telemetry->get_metrics_single_peer_async (channel0, [&done1] (nano::telemetry_data_response const & response_a) {
 		done1 = true;
 	});
 
@@ -635,7 +635,7 @@ TEST (telemetry, remove_peer_invalid_signature)
 	node->network.process_message (telemetry_ack, channel);
 
 	ASSERT_TIMELY (10s, node->stats.count (nano::stat::type::telemetry, nano::stat::detail::invalid_signature) > 0);
-	ASSERT_NO_ERROR (system.poll_until_true (3s, [&node, address = channel->get_endpoint ().address ()]() -> bool {
+	ASSERT_NO_ERROR (system.poll_until_true (3s, [&node, address = channel->get_endpoint ().address ()] () -> bool {
 		nano::lock_guard<nano::mutex> guard (node->network.excluded_peers.mutex);
 		return node->network.excluded_peers.peers.get<nano::peer_exclusion::tag_endpoint> ().count (address);
 	}));
@@ -662,7 +662,7 @@ TEST (telemetry, maker_pruning)
 	auto channel = node_client->network.find_channel (node_server->network.endpoint ());
 	{
 		std::atomic<bool> done{ false };
-		node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &server_endpoint, &telemetry_data](nano::telemetry_data_response const & response_a) {
+		node_client->telemetry->get_metrics_single_peer_async (channel, [&done, &server_endpoint, &telemetry_data] (nano::telemetry_data_response const & response_a) {
 			ASSERT_FALSE (response_a.error);
 			ASSERT_EQ (server_endpoint, response_a.endpoint);
 			telemetry_data = response_a.telemetry_data;
diff --git a/nano/core_test/utility.cpp b/nano/core_test/utility.cpp
index 0ae8a5a3f1..9cff9bdd92 100644
--- a/nano/core_test/utility.cpp
+++ b/nano/core_test/utility.cpp
@@ -95,7 +95,7 @@ TEST (thread, thread_pool)
 {
 	std::atomic<bool> passed_sleep{ false };
 
-	auto func = [&passed_sleep]() {
+	auto func = [&passed_sleep] () {
 		std::this_thread::sleep_for (std::chrono::seconds (1));
 		passed_sleep = true;
 	};
@@ -122,7 +122,7 @@ TEST (thread_pool_alarm, one)
 	std::atomic<bool> done (false);
 	nano::mutex mutex;
 	nano::condition_variable condition;
-	workers.add_timed_task (std::chrono::steady_clock::now (), [&]() {
+	workers.add_timed_task (std::chrono::steady_clock::now (), [&] () {
 		{
 			nano::lock_guard<nano::mutex> lock (mutex);
 			done = true;
@@ -130,7 +130,7 @@ TEST (thread_pool_alarm, one)
 		condition.notify_one ();
 	});
 	nano::unique_lock<nano::mutex> unique (mutex);
-	condition.wait (unique, [&]() { return !!done; });
+	condition.wait (unique, [&] () { return !!done; });
 }
 
 TEST (thread_pool_alarm, many)
@@ -141,7 +141,7 @@ TEST (thread_pool_alarm, many)
 	nano::condition_variable condition;
 	for (auto i (0); i < 50; ++i)
 	{
-		workers.add_timed_task (std::chrono::steady_clock::now (), [&]() {
+		workers.add_timed_task (std::chrono::steady_clock::now (), [&] () {
 			{
 				nano::lock_guard<nano::mutex> lock (mutex);
 				count += 1;
@@ -150,7 +150,7 @@ TEST (thread_pool_alarm, many)
 		});
 	}
 	nano::unique_lock<nano::mutex> unique (mutex);
-	condition.wait (unique, [&]() { return count == 50; });
+	condition.wait (unique, [&] () { return count == 50; });
 }
 
 TEST (thread_pool_alarm, top_execution)
@@ -160,12 +160,12 @@ TEST (thread_pool_alarm, top_execution)
 	int value2 (0);
 	nano::mutex mutex;
 	std::promise<bool> promise;
-	workers.add_timed_task (std::chrono::steady_clock::now (), [&]() {
+	workers.add_timed_task (std::chrono::steady_clock::now (), [&] () {
 		nano::lock_guard<nano::mutex> lock (mutex);
 		value1 = 1;
 		value2 = 1;
 	});
-	workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (1), [&]() {
+	workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (1), [&] () {
 		nano::lock_guard<nano::mutex> lock (mutex);
 		value2 = 2;
 		promise.set_value (false);
diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp
index 4fce89606a..72869e4ce1 100644
--- a/nano/core_test/vote_processor.cpp
+++ b/nano/core_test/vote_processor.cpp
@@ -193,14 +193,14 @@ TEST (vote_processor, no_broadcast_local)
 	// Reduce the weight of genesis to 2x default min voting weight
 	nano::keypair key;
 	std::shared_ptr<nano::block> send = builder.state ()
-	                                    .account (nano::dev_genesis_key.pub)
-	                                    .representative (nano::dev_genesis_key.pub)
-	                                    .previous (nano::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))
-	                                    .build (ec);
+										.account (nano::dev_genesis_key.pub)
+										.representative (nano::dev_genesis_key.pub)
+										.previous (nano::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))
+										.build (ec);
 	ASSERT_FALSE (ec);
 	ASSERT_EQ (nano::process_result::progress, node.process_local (send).code);
 	ASSERT_EQ (2 * node.config.vote_minimum.number (), node.weight (nano::dev_genesis_key.pub));
@@ -230,14 +230,14 @@ TEST (vote_processor, no_broadcast_local)
 	ASSERT_FALSE (node.wallets.reps ().exists (nano::dev_genesis_key.pub));
 
 	std::shared_ptr<nano::block> send2 = builder.state ()
-	                                     .account (nano::dev_genesis_key.pub)
-	                                     .representative (nano::dev_genesis_key.pub)
-	                                     .previous (send->hash ())
-	                                     .balance (node.config.vote_minimum)
-	                                     .link (key.pub)
-	                                     .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-	                                     .work (*system.work.generate (send->hash ()))
-	                                     .build (ec);
+										 .account (nano::dev_genesis_key.pub)
+										 .representative (nano::dev_genesis_key.pub)
+										 .previous (send->hash ())
+										 .balance (node.config.vote_minimum)
+										 .link (key.pub)
+										 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+										 .work (*system.work.generate (send->hash ()))
+										 .build (ec);
 	ASSERT_FALSE (ec);
 	ASSERT_EQ (nano::process_result::progress, node.process_local (send2).code);
 	ASSERT_EQ (node.config.vote_minimum, node.weight (nano::dev_genesis_key.pub));
@@ -259,14 +259,14 @@ TEST (vote_processor, no_broadcast_local)
 	// Repeat test with a PR in the wallet
 	// Increase the genesis weight again
 	std::shared_ptr<nano::block> open = builder.state ()
-	                                    .account (key.pub)
-	                                    .representative (nano::dev_genesis_key.pub)
-	                                    .previous (0)
-	                                    .balance (nano::genesis_amount - 2 * node.config.vote_minimum.number ())
-	                                    .link (send->hash ())
-	                                    .sign (key.prv, key.pub)
-	                                    .work (*system.work.generate (key.pub))
-	                                    .build (ec);
+										.account (key.pub)
+										.representative (nano::dev_genesis_key.pub)
+										.previous (0)
+										.balance (nano::genesis_amount - 2 * node.config.vote_minimum.number ())
+										.link (send->hash ())
+										.sign (key.prv, key.pub)
+										.work (*system.work.generate (key.pub))
+										.build (ec);
 	ASSERT_FALSE (ec);
 	ASSERT_EQ (nano::process_result::progress, node.process_local (open).code);
 	ASSERT_EQ (nano::genesis_amount - node.config.vote_minimum.number (), node.weight (nano::dev_genesis_key.pub));
diff --git a/nano/core_test/voting.cpp b/nano/core_test/voting.cpp
index d42e9d09d6..2abe3da48b 100644
--- a/nano/core_test/voting.cpp
+++ b/nano/core_test/voting.cpp
@@ -66,7 +66,7 @@ TEST (vote_generator, cache)
 	ASSERT_TIMELY (1s, !node.history.votes (epoch1->root (), epoch1->hash ()).empty ());
 	auto votes (node.history.votes (epoch1->root (), epoch1->hash ()));
 	ASSERT_FALSE (votes.empty ());
-	ASSERT_TRUE (std::any_of (votes[0]->begin (), votes[0]->end (), [hash = epoch1->hash ()](nano::block_hash const & hash_a) { return hash_a == hash; }));
+	ASSERT_TRUE (std::any_of (votes[0]->begin (), votes[0]->end (), [hash = epoch1->hash ()] (nano::block_hash const & hash_a) { return hash_a == hash; }));
 }
 
 TEST (vote_generator, multiple_representatives)
@@ -97,7 +97,7 @@ TEST (vote_generator, multiple_representatives)
 	auto votes (node.history.votes (send->root (), send->hash ()));
 	for (auto const & account : { key1.pub, key2.pub, key3.pub, nano::dev_genesis_key.pub })
 	{
-		auto existing (std::find_if (votes.begin (), votes.end (), [&account](std::shared_ptr<nano::vote> const & vote_a) -> bool {
+		auto existing (std::find_if (votes.begin (), votes.end (), [&account] (std::shared_ptr<nano::vote> const & vote_a) -> bool {
 			return vote_a->account == account;
 		}));
 		ASSERT_NE (votes.end (), existing);
@@ -110,7 +110,7 @@ TEST (vote_generator, session)
 	auto node (system.nodes[0]);
 	system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
 	nano::vote_generator_session generator_session (node->active.generator);
-	boost::thread thread ([node, &generator_session]() {
+	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);
 		ASSERT_EQ (0, node->stats.count (nano::stat::type::vote, nano::stat::detail::vote_indeterminate));
@@ -165,23 +165,23 @@ TEST (vote_spacing, vote_generator)
 	wallet.insert_adhoc (nano::dev_genesis_key.prv);
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::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))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::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))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::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))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::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))
+				 .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 ());
@@ -208,23 +208,23 @@ TEST (vote_spacing, rapid)
 	wallet.insert_adhoc (nano::dev_genesis_key.prv);
 	nano::state_block_builder builder;
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::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))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::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))
+				 .build_shared ();
 	auto send2 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::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))
-	             .build_shared ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::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))
+				 .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 ());
 	ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 1);
diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp
index 66df3fa9a8..d3b2bf3bfb 100644
--- a/nano/core_test/wallet.cpp
+++ b/nano/core_test/wallet.cpp
@@ -1201,14 +1201,14 @@ TEST (wallet, search_pending)
 	wallet.insert_adhoc (nano::dev_genesis_key.prv);
 	nano::block_builder builder;
 	auto send = builder.state ()
-	            .account (nano::genesis_account)
-	            .previous (nano::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))
-	            .build ();
+				.account (nano::genesis_account)
+				.previous (nano::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))
+				.build ();
 	ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
 
 	// Pending search should start an election
diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp
index 742dd7a001..21871a050d 100644
--- a/nano/core_test/wallets.cpp
+++ b/nano/core_test/wallets.cpp
@@ -190,14 +190,14 @@ TEST (wallets, search_pending)
 		wallet->insert_adhoc (nano::dev_genesis_key.prv);
 		nano::block_builder builder;
 		auto send = builder.state ()
-		            .account (nano::genesis_account)
-		            .previous (nano::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))
-		            .build ();
+					.account (nano::genesis_account)
+					.previous (nano::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))
+					.build ();
 		ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
 
 		// Pending search should start an election
diff --git a/nano/core_test/work_pool.cpp b/nano/core_test/work_pool.cpp
index 7d63204748..6dde98586e 100644
--- a/nano/core_test/work_pool.cpp
+++ b/nano/core_test/work_pool.cpp
@@ -50,7 +50,7 @@ TEST (work, cancel)
 	{
 		nano::root key (1);
 		pool.generate (
-		nano::work_version::work_1, key, nano::network_constants ().publish_thresholds.base, [&done](boost::optional<uint64_t> work_a) {
+		nano::work_version::work_1, key, nano::network_constants ().publish_thresholds.base, [&done] (boost::optional<uint64_t> work_a) {
 			done = !work_a;
 		});
 		pool.cancel (key);
@@ -69,12 +69,12 @@ TEST (work, cancel_many)
 	nano::root key5 (3);
 	nano::root key6 (1);
 	nano::network_constants constants;
-	pool.generate (nano::work_version::work_1, key1, constants.publish_thresholds.base, [](boost::optional<uint64_t>) {});
-	pool.generate (nano::work_version::work_1, key2, constants.publish_thresholds.base, [](boost::optional<uint64_t>) {});
-	pool.generate (nano::work_version::work_1, key3, constants.publish_thresholds.base, [](boost::optional<uint64_t>) {});
-	pool.generate (nano::work_version::work_1, key4, constants.publish_thresholds.base, [](boost::optional<uint64_t>) {});
-	pool.generate (nano::work_version::work_1, key5, constants.publish_thresholds.base, [](boost::optional<uint64_t>) {});
-	pool.generate (nano::work_version::work_1, key6, constants.publish_thresholds.base, [](boost::optional<uint64_t>) {});
+	pool.generate (nano::work_version::work_1, key1, constants.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
+	pool.generate (nano::work_version::work_1, key2, constants.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
+	pool.generate (nano::work_version::work_1, key3, constants.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
+	pool.generate (nano::work_version::work_1, key4, constants.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
+	pool.generate (nano::work_version::work_1, key5, constants.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
+	pool.generate (nano::work_version::work_1, key6, constants.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
 	pool.cancel (key1);
 }
 
@@ -93,7 +93,7 @@ TEST (work, opencl)
 		if (opencl != nullptr)
 		{
 			// 0 threads, should add 1 for managing OpenCL
-			nano::work_pool pool (0, std::chrono::nanoseconds (0), [&opencl](nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> & ticket_a) {
+			nano::work_pool pool (0, std::chrono::nanoseconds (0), [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> & ticket_a) {
 				return opencl->generate_work (version_a, root_a, difficulty_a);
 			});
 			ASSERT_NE (nullptr, pool.opencl);
@@ -159,7 +159,7 @@ TEST (work, difficulty)
 
 TEST (work, eco_pow)
 {
-	auto work_func = [](std::promise<std::chrono::nanoseconds> & promise, std::chrono::nanoseconds interval) {
+	auto work_func = [] (std::promise<std::chrono::nanoseconds> & promise, std::chrono::nanoseconds interval) {
 		nano::work_pool pool (1, interval);
 		constexpr auto num_iterations = 5;
 
diff --git a/nano/ipc_flatbuffers_lib/flatbuffer_producer.cpp b/nano/ipc_flatbuffers_lib/flatbuffer_producer.cpp
index 9a8692fe51..17d3f8bac6 100644
--- a/nano/ipc_flatbuffers_lib/flatbuffer_producer.cpp
+++ b/nano/ipc_flatbuffers_lib/flatbuffer_producer.cpp
@@ -6,7 +6,7 @@ nano::ipc::flatbuffer_producer::flatbuffer_producer ()
 }
 
 nano::ipc::flatbuffer_producer::flatbuffer_producer (std::shared_ptr<flatbuffers::FlatBufferBuilder> const & builder_a) :
-fbb (builder_a)
+	fbb (builder_a)
 {
 }
 
diff --git a/nano/ipc_flatbuffers_test/entry.cpp b/nano/ipc_flatbuffers_test/entry.cpp
index 1b3c7e1e81..cdffb68743 100644
--- a/nano/ipc_flatbuffers_test/entry.cpp
+++ b/nano/ipc_flatbuffers_test/entry.cpp
@@ -16,7 +16,7 @@ namespace
 void read_message_loop (std::shared_ptr<nano::ipc::ipc_client> const & connection)
 {
 	auto buffer (std::make_shared<std::vector<uint8_t>> ());
-	connection->async_read_message (buffer, std::chrono::seconds::max (), [buffer, connection](nano::error error_a, size_t size_a) {
+	connection->async_read_message (buffer, std::chrono::seconds::max (), [buffer, connection] (nano::error error_a, size_t size_a) {
 		if (!error_a)
 		{
 			auto verifier (flatbuffers::Verifier (buffer->data (), buffer->size ()));
@@ -57,11 +57,11 @@ int main (int argc, char * const * argv)
 	// be improved later to handle various options, including port and address.
 	std::string ipc_address = "::1";
 	uint16_t ipc_port = 7077;
-	connection->async_connect (ipc_address, ipc_port, [connection](nano::error err) {
+	connection->async_connect (ipc_address, ipc_port, [connection] (nano::error err) {
 		if (!err)
 		{
 			nanoapi::TopicConfirmationT conf;
-			connection->async_write (nano::ipc::shared_buffer_from (conf), [connection](nano::error err, size_t size) {
+			connection->async_write (nano::ipc::shared_buffer_from (conf), [connection] (nano::error err, size_t size) {
 				if (!err)
 				{
 					std::cout << "Awaiting confirmations..." << std::endl;
diff --git a/nano/lib/asio.cpp b/nano/lib/asio.cpp
index fac8c1008d..6d0a5b7fed 100644
--- a/nano/lib/asio.cpp
+++ b/nano/lib/asio.cpp
@@ -1,31 +1,31 @@
 #include <nano/lib/asio.hpp>
 
 nano::shared_const_buffer::shared_const_buffer (const std::vector<uint8_t> & data) :
-m_data (std::make_shared<std::vector<uint8_t>> (data)),
-m_buffer (boost::asio::buffer (*m_data))
+	m_data (std::make_shared<std::vector<uint8_t>> (data)),
+	m_buffer (boost::asio::buffer (*m_data))
 {
 }
 
 nano::shared_const_buffer::shared_const_buffer (std::vector<uint8_t> && data) :
-m_data (std::make_shared<std::vector<uint8_t>> (std::move (data))),
-m_buffer (boost::asio::buffer (*m_data))
+	m_data (std::make_shared<std::vector<uint8_t>> (std::move (data))),
+	m_buffer (boost::asio::buffer (*m_data))
 {
 }
 
 nano::shared_const_buffer::shared_const_buffer (uint8_t data) :
-shared_const_buffer (std::vector<uint8_t>{ data })
+	shared_const_buffer (std::vector<uint8_t>{ data })
 {
 }
 
 nano::shared_const_buffer::shared_const_buffer (std::string const & data) :
-m_data (std::make_shared<std::vector<uint8_t>> (data.begin (), data.end ())),
-m_buffer (boost::asio::buffer (*m_data))
+	m_data (std::make_shared<std::vector<uint8_t>> (data.begin (), data.end ())),
+	m_buffer (boost::asio::buffer (*m_data))
 {
 }
 
 nano::shared_const_buffer::shared_const_buffer (std::shared_ptr<std::vector<uint8_t>> const & data) :
-m_data (data),
-m_buffer (boost::asio::buffer (*m_data))
+	m_data (data),
+	m_buffer (boost::asio::buffer (*m_data))
 {
 }
 
diff --git a/nano/lib/asio.hpp b/nano/lib/asio.hpp
index 211a18ed46..c2b388fa29 100644
--- a/nano/lib/asio.hpp
+++ b/nano/lib/asio.hpp
@@ -29,7 +29,7 @@ class shared_const_buffer
 static_assert (boost::asio::is_const_buffer_sequence<shared_const_buffer>::value, "Not ConstBufferSequence compliant");
 
 template <typename AsyncWriteStream, typename WriteHandler>
-BOOST_ASIO_INITFN_RESULT_TYPE (WriteHandler, void(boost::system::error_code, std::size_t))
+BOOST_ASIO_INITFN_RESULT_TYPE (WriteHandler, void (boost::system::error_code, std::size_t))
 async_write (AsyncWriteStream & s, nano::shared_const_buffer const & buffer, WriteHandler && handler)
 {
 	return boost::asio::async_write (s, buffer, std::move (handler));
@@ -41,7 +41,7 @@ async_write (AsyncWriteStream & s, nano::shared_const_buffer const & buffer, Wri
  * @warning The buffers must be captured in the handler to ensure their lifetimes are properly extended.
  */
 template <typename AsyncWriteStream, typename BufferType, typename WriteHandler>
-BOOST_ASIO_INITFN_RESULT_TYPE (WriteHandler, void(boost::system::error_code, std::size_t))
+BOOST_ASIO_INITFN_RESULT_TYPE (WriteHandler, void (boost::system::error_code, std::size_t))
 unsafe_async_write (AsyncWriteStream & s, BufferType && buffer, WriteHandler && handler)
 {
 	return boost::asio::async_write (s, buffer, std::move (handler));
diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp
index 70c4570f54..4515b78d07 100644
--- a/nano/lib/blocks.cpp
+++ b/nano/lib/blocks.cpp
@@ -221,9 +221,9 @@ void nano::send_block::block_work_set (uint64_t work_a)
 }
 
 nano::send_hashables::send_hashables (nano::block_hash const & previous_a, nano::account const & destination_a, nano::amount const & balance_a) :
-previous (previous_a),
-destination (destination_a),
-balance (balance_a)
+	previous (previous_a),
+	destination (destination_a),
+	balance (balance_a)
 {
 }
 
@@ -364,14 +364,14 @@ bool nano::send_block::deserialize_json (boost::property_tree::ptree const & tre
 }
 
 nano::send_block::send_block (nano::block_hash const & previous_a, nano::account const & destination_a, nano::amount const & balance_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) :
-hashables (previous_a, destination_a, balance_a),
-signature (nano::sign_message (prv_a, pub_a, hash ())),
-work (work_a)
+	hashables (previous_a, destination_a, balance_a),
+	signature (nano::sign_message (prv_a, pub_a, hash ())),
+	work (work_a)
 {
 }
 
 nano::send_block::send_block (bool & error_a, nano::stream & stream_a) :
-hashables (error_a, stream_a)
+	hashables (error_a, stream_a)
 {
 	if (!error_a)
 	{
@@ -388,7 +388,7 @@ hashables (error_a, stream_a)
 }
 
 nano::send_block::send_block (bool & error_a, boost::property_tree::ptree const & tree_a) :
-hashables (error_a, tree_a)
+	hashables (error_a, tree_a)
 {
 	if (!error_a)
 	{
@@ -474,9 +474,9 @@ void nano::send_block::signature_set (nano::signature const & signature_a)
 }
 
 nano::open_hashables::open_hashables (nano::block_hash const & source_a, nano::account const & representative_a, nano::account const & account_a) :
-source (source_a),
-representative (representative_a),
-account (account_a)
+	source (source_a),
+	representative (representative_a),
+	account (account_a)
 {
 }
 
@@ -525,22 +525,22 @@ void nano::open_hashables::hash (blake2b_state & hash_a) const
 }
 
 nano::open_block::open_block (nano::block_hash const & source_a, nano::account const & representative_a, nano::account const & account_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) :
-hashables (source_a, representative_a, account_a),
-signature (nano::sign_message (prv_a, pub_a, hash ())),
-work (work_a)
+	hashables (source_a, representative_a, account_a),
+	signature (nano::sign_message (prv_a, pub_a, hash ())),
+	work (work_a)
 {
 	debug_assert (!representative_a.is_zero ());
 }
 
 nano::open_block::open_block (nano::block_hash const & source_a, nano::account const & representative_a, nano::account const & account_a, std::nullptr_t) :
-hashables (source_a, representative_a, account_a),
-work (0)
+	hashables (source_a, representative_a, account_a),
+	work (0)
 {
 	signature.clear ();
 }
 
 nano::open_block::open_block (bool & error_a, nano::stream & stream_a) :
-hashables (error_a, stream_a)
+	hashables (error_a, stream_a)
 {
 	if (!error_a)
 	{
@@ -557,7 +557,7 @@ hashables (error_a, stream_a)
 }
 
 nano::open_block::open_block (bool & error_a, boost::property_tree::ptree const & tree_a) :
-hashables (error_a, tree_a)
+	hashables (error_a, tree_a)
 {
 	if (!error_a)
 	{
@@ -745,8 +745,8 @@ void nano::open_block::signature_set (nano::signature const & signature_a)
 }
 
 nano::change_hashables::change_hashables (nano::block_hash const & previous_a, nano::account const & representative_a) :
-previous (previous_a),
-representative (representative_a)
+	previous (previous_a),
+	representative (representative_a)
 {
 }
 
@@ -788,14 +788,14 @@ void nano::change_hashables::hash (blake2b_state & hash_a) const
 }
 
 nano::change_block::change_block (nano::block_hash const & previous_a, nano::account const & representative_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) :
-hashables (previous_a, representative_a),
-signature (nano::sign_message (prv_a, pub_a, hash ())),
-work (work_a)
+	hashables (previous_a, representative_a),
+	signature (nano::sign_message (prv_a, pub_a, hash ())),
+	work (work_a)
 {
 }
 
 nano::change_block::change_block (bool & error_a, nano::stream & stream_a) :
-hashables (error_a, stream_a)
+	hashables (error_a, stream_a)
 {
 	if (!error_a)
 	{
@@ -812,7 +812,7 @@ hashables (error_a, stream_a)
 }
 
 nano::change_block::change_block (bool & error_a, boost::property_tree::ptree const & tree_a) :
-hashables (error_a, tree_a)
+	hashables (error_a, tree_a)
 {
 	if (!error_a)
 	{
@@ -994,11 +994,11 @@ void nano::change_block::signature_set (nano::signature const & signature_a)
 }
 
 nano::state_hashables::state_hashables (nano::account const & account_a, nano::block_hash const & previous_a, nano::account const & representative_a, nano::amount const & balance_a, nano::link const & link_a) :
-account (account_a),
-previous (previous_a),
-representative (representative_a),
-balance (balance_a),
-link (link_a)
+	account (account_a),
+	previous (previous_a),
+	representative (representative_a),
+	balance (balance_a),
+	link (link_a)
 {
 }
 
@@ -1061,14 +1061,14 @@ void nano::state_hashables::hash (blake2b_state & hash_a) const
 }
 
 nano::state_block::state_block (nano::account const & account_a, nano::block_hash const & previous_a, nano::account const & representative_a, nano::amount const & balance_a, nano::link const & link_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) :
-hashables (account_a, previous_a, representative_a, balance_a, link_a),
-signature (nano::sign_message (prv_a, pub_a, hash ())),
-work (work_a)
+	hashables (account_a, previous_a, representative_a, balance_a, link_a),
+	signature (nano::sign_message (prv_a, pub_a, hash ())),
+	work (work_a)
 {
 }
 
 nano::state_block::state_block (bool & error_a, nano::stream & stream_a) :
-hashables (error_a, stream_a)
+	hashables (error_a, stream_a)
 {
 	if (!error_a)
 	{
@@ -1086,7 +1086,7 @@ hashables (error_a, stream_a)
 }
 
 nano::state_block::state_block (bool & error_a, boost::property_tree::ptree const & tree_a) :
-hashables (error_a, tree_a)
+	hashables (error_a, tree_a)
 {
 	if (!error_a)
 	{
@@ -1506,14 +1506,14 @@ bool nano::receive_block::deserialize_json (boost::property_tree::ptree const &
 }
 
 nano::receive_block::receive_block (nano::block_hash const & previous_a, nano::block_hash const & source_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) :
-hashables (previous_a, source_a),
-signature (nano::sign_message (prv_a, pub_a, hash ())),
-work (work_a)
+	hashables (previous_a, source_a),
+	signature (nano::sign_message (prv_a, pub_a, hash ())),
+	work (work_a)
 {
 }
 
 nano::receive_block::receive_block (bool & error_a, nano::stream & stream_a) :
-hashables (error_a, stream_a)
+	hashables (error_a, stream_a)
 {
 	if (!error_a)
 	{
@@ -1530,7 +1530,7 @@ hashables (error_a, stream_a)
 }
 
 nano::receive_block::receive_block (bool & error_a, boost::property_tree::ptree const & tree_a) :
-hashables (error_a, tree_a)
+	hashables (error_a, tree_a)
 {
 	if (!error_a)
 	{
@@ -1620,8 +1620,8 @@ nano::block_type nano::receive_block::type () const
 }
 
 nano::receive_hashables::receive_hashables (nano::block_hash const & previous_a, nano::block_hash const & source_a) :
-previous (previous_a),
-source (source_a)
+	previous (previous_a),
+	source (source_a)
 {
 }
 
@@ -1663,7 +1663,7 @@ void nano::receive_hashables::hash (blake2b_state & hash_a) const
 }
 
 nano::block_details::block_details (nano::epoch const epoch_a, bool const is_send_a, bool const is_receive_a, bool const is_epoch_a) :
-epoch (epoch_a), is_send (is_send_a), is_receive (is_receive_a), is_epoch (is_epoch_a)
+	epoch (epoch_a), is_send (is_send_a), is_receive (is_receive_a), is_epoch (is_epoch_a)
 {
 }
 
@@ -1735,24 +1735,24 @@ std::string nano::state_subtype (nano::block_details const details_a)
 }
 
 nano::block_sideband::block_sideband (nano::account const & account_a, nano::block_hash const & successor_a, nano::amount const & balance_a, uint64_t const height_a, uint64_t const timestamp_a, nano::block_details const & details_a, nano::epoch const source_epoch_a) :
-successor (successor_a),
-account (account_a),
-balance (balance_a),
-height (height_a),
-timestamp (timestamp_a),
-details (details_a),
-source_epoch (source_epoch_a)
+	successor (successor_a),
+	account (account_a),
+	balance (balance_a),
+	height (height_a),
+	timestamp (timestamp_a),
+	details (details_a),
+	source_epoch (source_epoch_a)
 {
 }
 
 nano::block_sideband::block_sideband (nano::account const & account_a, nano::block_hash const & successor_a, nano::amount const & balance_a, uint64_t const height_a, uint64_t const timestamp_a, nano::epoch const epoch_a, bool const is_send, bool const is_receive, bool const is_epoch, nano::epoch const source_epoch_a) :
-successor (successor_a),
-account (account_a),
-balance (balance_a),
-height (height_a),
-timestamp (timestamp_a),
-details (epoch_a, is_send, is_receive, is_epoch),
-source_epoch (source_epoch_a)
+	successor (successor_a),
+	account (account_a),
+	balance (balance_a),
+	height (height_a),
+	timestamp (timestamp_a),
+	details (epoch_a, is_send, is_receive, is_epoch),
+	source_epoch (source_epoch_a)
 {
 }
 
diff --git a/nano/lib/config.hpp b/nano/lib/config.hpp
index cd3128f6ce..aa492d73b4 100644
--- a/nano/lib/config.hpp
+++ b/nano/lib/config.hpp
@@ -92,9 +92,9 @@ struct work_thresholds
 	uint64_t const entry;
 
 	constexpr work_thresholds (uint64_t epoch_1_a, uint64_t epoch_2_a, uint64_t epoch_2_receive_a) :
-	epoch_1 (epoch_1_a), epoch_2 (epoch_2_a), epoch_2_receive (epoch_2_receive_a),
-	base (std::max ({ epoch_1, epoch_2, epoch_2_receive })),
-	entry (std::min ({ epoch_1, epoch_2, epoch_2_receive }))
+		epoch_1 (epoch_1_a), epoch_2 (epoch_2_a), epoch_2_receive (epoch_2_receive_a),
+		base (std::max ({ epoch_1, epoch_2, epoch_2_receive })),
+		entry (std::min ({ epoch_1, epoch_2, epoch_2_receive }))
 	{
 	}
 	work_thresholds () = delete;
@@ -108,13 +108,13 @@ class network_constants
 {
 public:
 	network_constants () :
-	network_constants (network_constants::active_network)
+		network_constants (network_constants::active_network)
 	{
 	}
 
 	network_constants (nano_networks network_a) :
-	current_network (network_a),
-	publish_thresholds (is_live_network () ? publish_full : is_beta_network () ? publish_beta : is_test_network () ? publish_test : publish_dev)
+		current_network (network_a),
+		publish_thresholds (is_live_network () ? publish_full : is_beta_network () ? publish_beta : is_test_network () ? publish_test : publish_dev)
 	{
 		// A representative is classified as principal based on its weight and this factor
 		principal_weight_factor = 1000; // 0.1%
diff --git a/nano/lib/configbase.hpp b/nano/lib/configbase.hpp
index f1eb10792f..e19491aa86 100644
--- a/nano/lib/configbase.hpp
+++ b/nano/lib/configbase.hpp
@@ -14,7 +14,7 @@ namespace nano
 /** Type trait to determine if T is compatible with boost's lexical_cast */
 template <class T>
 struct is_lexical_castable : std::integral_constant<bool,
-                             (std::is_default_constructible<T>::value && (boost::has_right_shift<std::basic_istream<wchar_t>, T>::value || boost::has_right_shift<std::basic_istream<char>, T>::value))>
+							 (std::is_default_constructible<T>::value && (boost::has_right_shift<std::basic_istream<wchar_t>, T>::value || boost::has_right_shift<std::basic_istream<char>, T>::value))>
 {
 };
 
@@ -42,7 +42,7 @@ class configbase : public nano::error_aware<>
 public:
 	configbase () = default;
 	configbase (std::shared_ptr<nano::error> const & error_a) :
-	error (error_a)
+		error (error_a)
 	{
 	}
 
diff --git a/nano/lib/epoch.cpp b/nano/lib/epoch.cpp
index 226d1bb41c..d300cc6223 100644
--- a/nano/lib/epoch.cpp
+++ b/nano/lib/epoch.cpp
@@ -8,7 +8,7 @@ nano::link const & nano::epochs::link (nano::epoch epoch_a) const
 
 bool nano::epochs::is_epoch_link (nano::link const & link_a) const
 {
-	return std::any_of (epochs_m.begin (), epochs_m.end (), [&link_a](auto const & item_a) { return item_a.second.link == link_a; });
+	return std::any_of (epochs_m.begin (), epochs_m.end (), [&link_a] (auto const & item_a) { return item_a.second.link == link_a; });
 }
 
 nano::public_key const & nano::epochs::signer (nano::epoch epoch_a) const
@@ -18,7 +18,7 @@ nano::public_key const & nano::epochs::signer (nano::epoch epoch_a) const
 
 nano::epoch nano::epochs::epoch (nano::link const & link_a) const
 {
-	auto existing (std::find_if (epochs_m.begin (), epochs_m.end (), [&link_a](auto const & item_a) { return item_a.second.link == link_a; }));
+	auto existing (std::find_if (epochs_m.begin (), epochs_m.end (), [&link_a] (auto const & item_a) { return item_a.second.link == link_a; }));
 	debug_assert (existing != epochs_m.end ());
 	return existing->first;
 }
diff --git a/nano/lib/errors.hpp b/nano/lib/errors.hpp
index a47171ea8a..4694818fe4 100644
--- a/nano/lib/errors.hpp
+++ b/nano/lib/errors.hpp
@@ -209,7 +209,7 @@ namespace std
 {
 template <>
 struct is_error_code_enum<boost::system::errc::errc_t>
-: public std::true_type
+	: public std::true_type
 {
 };
 
@@ -262,7 +262,7 @@ class error
 	{
 		// Convert variadic arguments to std::error_code
 		auto codes = { std::error_code (err)... };
-		if (std::any_of (codes.begin (), codes.end (), [this, &codes](auto & code_a) { return code == code_a; }))
+		if (std::any_of (codes.begin (), codes.end (), [this, &codes] (auto & code_a) { return code == code_a; }))
 		{
 			code.clear ();
 		}
diff --git a/nano/lib/ipc.cpp b/nano/lib/ipc.cpp
index 41ae3cb5ca..82a7ce2e33 100644
--- a/nano/lib/ipc.cpp
+++ b/nano/lib/ipc.cpp
@@ -2,7 +2,7 @@
 #include <nano/lib/utility.hpp>
 
 nano::ipc::socket_base::socket_base (boost::asio::io_context & io_ctx_a) :
-io_timer (io_ctx_a)
+	io_timer (io_ctx_a)
 {
 }
 
@@ -11,7 +11,7 @@ void nano::ipc::socket_base::timer_start (std::chrono::seconds timeout_a)
 	if (timeout_a < std::chrono::seconds::max ())
 	{
 		io_timer.expires_from_now (boost::posix_time::seconds (static_cast<long> (timeout_a.count ())));
-		io_timer.async_wait ([this](const boost::system::error_code & ec) {
+		io_timer.async_wait ([this] (const boost::system::error_code & ec) {
 			if (!ec)
 			{
 				this->timer_expired ();
@@ -33,7 +33,7 @@ void nano::ipc::socket_base::timer_cancel ()
 }
 
 nano::ipc::dsock_file_remover::dsock_file_remover (std::string const & file_a) :
-filename (file_a)
+	filename (file_a)
 {
 	std::remove (filename.c_str ());
 }
diff --git a/nano/lib/ipc_client.cpp b/nano/lib/ipc_client.cpp
index 8f706a994b..8be1091a87 100644
--- a/nano/lib/ipc_client.cpp
+++ b/nano/lib/ipc_client.cpp
@@ -19,8 +19,8 @@ namespace
 class channel
 {
 public:
-	virtual void async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void(boost::system::error_code const &, size_t)> callback_a) = 0;
-	virtual void async_write (nano::shared_const_buffer const & buffer_a, std::function<void(boost::system::error_code const &, size_t)> callback_a) = 0;
+	virtual void async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void (boost::system::error_code const &, size_t)> callback_a) = 0;
+	virtual void async_write (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, size_t)> callback_a) = 0;
 
 	/**
 	 * Read a length-prefixed message asynchronously using the given timeout. This is suitable for full duplex scenarios where it may
@@ -30,7 +30,7 @@ class channel
 	 * @param timeout_a How long to await message data. In some scenarios, such as waiting for data on subscriptions, specifying std::chrono::seconds::max() makes sense.
 	 * @param callback_a If called without errors, the payload buffer is successfully populated
 	 */
-	virtual void async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void(boost::system::error_code const &, size_t)> callback_a) = 0;
+	virtual void async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void (boost::system::error_code const &, size_t)> callback_a) = 0;
 };
 
 /* Boost v1.70 introduced breaking changes; the conditional compilation allows 1.6x to be supported as well. */
@@ -46,15 +46,15 @@ class socket_client : public nano::ipc::socket_base, public channel, public std:
 {
 public:
 	socket_client (boost::asio::io_context & io_ctx_a, ENDPOINT_TYPE endpoint_a) :
-	socket_base (io_ctx_a), endpoint (endpoint_a), socket (io_ctx_a), resolver (io_ctx_a), strand (io_ctx_a.get_executor ())
+		socket_base (io_ctx_a), endpoint (endpoint_a), socket (io_ctx_a), resolver (io_ctx_a), strand (io_ctx_a.get_executor ())
 	{
 	}
 
-	void async_resolve (std::string const & host_a, uint16_t port_a, std::function<void(boost::system::error_code const &, boost::asio::ip::tcp::endpoint)> callback_a)
+	void async_resolve (std::string const & host_a, uint16_t port_a, std::function<void (boost::system::error_code const &, boost::asio::ip::tcp::endpoint)> callback_a)
 	{
 		auto this_l (this->shared_from_this ());
 		this_l->timer_start (io_timeout);
-		resolver.async_resolve (boost::asio::ip::tcp::resolver::query (host_a, std::to_string (port_a)), [this_l, callback_a](boost::system::error_code const & ec, boost::asio::ip::tcp::resolver::iterator endpoint_iterator_a) {
+		resolver.async_resolve (boost::asio::ip::tcp::resolver::query (host_a, std::to_string (port_a)), [this_l, callback_a] (boost::system::error_code const & ec, boost::asio::ip::tcp::resolver::iterator endpoint_iterator_a) {
 			this_l->timer_cancel ();
 			boost::asio::ip::tcp::resolver::iterator end;
 			if (!ec && endpoint_iterator_a != end)
@@ -69,31 +69,31 @@ class socket_client : public nano::ipc::socket_base, public channel, public std:
 		});
 	}
 
-	void async_connect (std::function<void(boost::system::error_code const &)> callback_a)
+	void async_connect (std::function<void (boost::system::error_code const &)> callback_a)
 	{
 		auto this_l (this->shared_from_this ());
 		this_l->timer_start (io_timeout);
-		socket.async_connect (endpoint, boost::asio::bind_executor (strand, [this_l, callback_a](boost::system::error_code const & ec) {
+		socket.async_connect (endpoint, boost::asio::bind_executor (strand, [this_l, callback_a] (boost::system::error_code const & ec) {
 			this_l->timer_cancel ();
 			callback_a (ec);
 		}));
 	}
 
-	void async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void(boost::system::error_code const &, size_t)> callback_a) override
+	void async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void (boost::system::error_code const &, size_t)> callback_a) override
 	{
 		auto this_l (this->shared_from_this ());
 		this_l->timer_start (io_timeout);
 		buffer_a->resize (size_a);
-		boost::asio::async_read (socket, boost::asio::buffer (buffer_a->data (), size_a), boost::asio::bind_executor (this_l->strand, [this_l, buffer_a, callback_a](boost::system::error_code const & ec, size_t size_a) {
+		boost::asio::async_read (socket, boost::asio::buffer (buffer_a->data (), size_a), boost::asio::bind_executor (this_l->strand, [this_l, buffer_a, callback_a] (boost::system::error_code const & ec, size_t size_a) {
 			this_l->timer_cancel ();
 			callback_a (ec, size_a);
 		}));
 	}
 
-	void async_write (nano::shared_const_buffer const & buffer_a, std::function<void(boost::system::error_code const &, size_t)> callback_a) override
+	void async_write (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, size_t)> callback_a) override
 	{
 		auto this_l (this->shared_from_this ());
-		boost::asio::post (strand, boost::asio::bind_executor (strand, [buffer_a, callback_a, this_l]() {
+		boost::asio::post (strand, boost::asio::bind_executor (strand, [buffer_a, callback_a, this_l] () {
 			bool write_in_progress = !this_l->send_queue.empty ();
 			auto queue_size = this_l->send_queue.size ();
 			if (queue_size < this_l->queue_size_max)
@@ -114,7 +114,7 @@ class socket_client : public nano::ipc::socket_base, public channel, public std:
 		this_l->timer_start (io_timeout);
 		nano::async_write (socket, msg.buffer,
 		boost::asio::bind_executor (strand,
-		[msg, this_l](boost::system::error_code ec, std::size_t size_a) {
+		[msg, this_l] (boost::system::error_code ec, std::size_t size_a) {
 			this_l->timer_cancel ();
 
 			if (msg.callback)
@@ -130,13 +130,13 @@ class socket_client : public nano::ipc::socket_base, public channel, public std:
 		}));
 	}
 
-	void async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void(boost::system::error_code const &, size_t)> callback_a) override
+	void async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void (boost::system::error_code const &, size_t)> callback_a) override
 	{
 		auto this_l (this->shared_from_this ());
 		this_l->timer_start (timeout_a);
 		buffer_a->resize (4);
 		// Read 32 bit big-endian length
-		boost::asio::async_read (socket, boost::asio::buffer (buffer_a->data (), 4), boost::asio::bind_executor (this_l->strand, [this_l, timeout_a, buffer_a, callback_a](boost::system::error_code const & ec, size_t size_a) {
+		boost::asio::async_read (socket, boost::asio::buffer (buffer_a->data (), 4), boost::asio::bind_executor (this_l->strand, [this_l, timeout_a, buffer_a, callback_a] (boost::system::error_code const & ec, size_t size_a) {
 			this_l->timer_cancel ();
 			if (!ec)
 			{
@@ -144,7 +144,7 @@ class socket_client : public nano::ipc::socket_base, public channel, public std:
 				buffer_a->resize (payload_size_l);
 				// Read payload
 				this_l->timer_start (timeout_a);
-				this_l->async_read (buffer_a, payload_size_l, [this_l, buffer_a, callback_a](boost::system::error_code const & ec_a, size_t size_a) {
+				this_l->async_read (buffer_a, payload_size_l, [this_l, buffer_a, callback_a] (boost::system::error_code const & ec_a, size_t size_a) {
 					this_l->timer_cancel ();
 					callback_a (ec_a, size_a);
 				});
@@ -160,7 +160,7 @@ class socket_client : public nano::ipc::socket_base, public channel, public std:
 	void close () override
 	{
 		auto this_l (this->shared_from_this ());
-		boost::asio::post (strand, boost::asio::bind_executor (strand, [this_l]() {
+		boost::asio::post (strand, boost::asio::bind_executor (strand, [this_l] () {
 			this_l->socket.shutdown (boost::asio::ip::tcp::socket::shutdown_both);
 			this_l->socket.close ();
 		}));
@@ -171,12 +171,12 @@ class socket_client : public nano::ipc::socket_base, public channel, public std:
 	class queue_item
 	{
 	public:
-		queue_item (nano::shared_const_buffer const & buffer_a, std::function<void(boost::system::error_code const &, size_t)> callback_a) :
-		buffer (buffer_a), callback (callback_a)
+		queue_item (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, size_t)> callback_a) :
+			buffer (buffer_a), callback (callback_a)
 		{
 		}
 		nano::shared_const_buffer buffer;
-		std::function<void(boost::system::error_code const &, size_t)> callback;
+		std::function<void (boost::system::error_code const &, size_t)> callback;
 	};
 	size_t const queue_size_max = 64 * 1024;
 	/** The send queue is protected by always being accessed through the strand */
@@ -197,18 +197,18 @@ class client_impl : public nano::ipc::ipc_client_impl
 {
 public:
 	explicit client_impl (boost::asio::io_context & io_ctx_a) :
-	io_ctx (io_ctx_a)
+		io_ctx (io_ctx_a)
 	{
 	}
 
-	void connect (std::string const & host_a, uint16_t port_a, std::function<void(nano::error)> callback_a)
+	void connect (std::string const & host_a, uint16_t port_a, std::function<void (nano::error)> callback_a)
 	{
 		tcp_client = std::make_shared<socket_client<socket_type, boost::asio::ip::tcp::endpoint>> (io_ctx, boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v6 (), port_a));
 
-		tcp_client->async_resolve (host_a, port_a, [this, callback_a](boost::system::error_code const & ec_resolve_a, boost::asio::ip::tcp::endpoint endpoint_a) {
+		tcp_client->async_resolve (host_a, port_a, [this, callback_a] (boost::system::error_code const & ec_resolve_a, boost::asio::ip::tcp::endpoint endpoint_a) {
 			if (!ec_resolve_a)
 			{
-				this->tcp_client->async_connect ([callback_a](const boost::system::error_code & ec_connect_a) {
+				this->tcp_client->async_connect ([callback_a] (const boost::system::error_code & ec_connect_a) {
 					callback_a (nano::error (ec_connect_a));
 				});
 			}
@@ -249,7 +249,7 @@ class client_impl : public nano::ipc::ipc_client_impl
 }
 
 nano::ipc::ipc_client::ipc_client (boost::asio::io_context & io_ctx_a) :
-io_ctx (io_ctx_a)
+	io_ctx (io_ctx_a)
 {
 }
 
@@ -259,7 +259,7 @@ nano::error nano::ipc::ipc_client::connect (std::string const & path_a)
 	return boost::polymorphic_downcast<client_impl *> (impl.get ())->connect (path_a);
 }
 
-void nano::ipc::ipc_client::async_connect (std::string const & host_a, uint16_t port_a, std::function<void(nano::error)> callback_a)
+void nano::ipc::ipc_client::async_connect (std::string const & host_a, uint16_t port_a, std::function<void (nano::error)> callback_a)
 {
 	impl = std::make_unique<client_impl> (io_ctx);
 	auto client (boost::polymorphic_downcast<client_impl *> (impl.get ()));
@@ -269,33 +269,33 @@ void nano::ipc::ipc_client::async_connect (std::string const & host_a, uint16_t
 nano::error nano::ipc::ipc_client::connect (std::string const & host, uint16_t port)
 {
 	std::promise<nano::error> result_l;
-	async_connect (host, port, [&result_l](nano::error err_a) {
+	async_connect (host, port, [&result_l] (nano::error err_a) {
 		result_l.set_value (err_a);
 	});
 	return result_l.get_future ().get ();
 }
 
-void nano::ipc::ipc_client::async_write (nano::shared_const_buffer const & buffer_a, std::function<void(nano::error, size_t)> callback_a)
+void nano::ipc::ipc_client::async_write (nano::shared_const_buffer const & buffer_a, std::function<void (nano::error, size_t)> callback_a)
 {
 	auto client (boost::polymorphic_downcast<client_impl *> (impl.get ()));
-	client->get_channel ().async_write (buffer_a, [callback_a](const boost::system::error_code & ec_a, size_t bytes_written_a) {
+	client->get_channel ().async_write (buffer_a, [callback_a] (const boost::system::error_code & ec_a, size_t bytes_written_a) {
 		callback_a (nano::error (ec_a), bytes_written_a);
 	});
 }
 
-void nano::ipc::ipc_client::async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void(nano::error, size_t)> callback_a)
+void nano::ipc::ipc_client::async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void (nano::error, size_t)> callback_a)
 {
 	auto client (boost::polymorphic_downcast<client_impl *> (impl.get ()));
-	client->get_channel ().async_read (buffer_a, size_a, [callback_a, buffer_a](const boost::system::error_code & ec_a, size_t bytes_read_a) {
+	client->get_channel ().async_read (buffer_a, size_a, [callback_a, buffer_a] (const boost::system::error_code & ec_a, size_t bytes_read_a) {
 		callback_a (nano::error (ec_a), bytes_read_a);
 	});
 }
 
 /** Read a length-prefixed message asynchronously. Received length must be a big endian 32-bit unsigned integer. */
-void nano::ipc::ipc_client::async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void(nano::error, size_t)> callback_a)
+void nano::ipc::ipc_client::async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void (nano::error, size_t)> callback_a)
 {
 	auto client (boost::polymorphic_downcast<client_impl *> (impl.get ()));
-	client->get_channel ().async_read_message (buffer_a, timeout_a, [callback_a, buffer_a](const boost::system::error_code & ec_a, size_t bytes_read_a) {
+	client->get_channel ().async_read_message (buffer_a, timeout_a, [callback_a, buffer_a] (const boost::system::error_code & ec_a, size_t bytes_read_a) {
 		callback_a (nano::error (ec_a), bytes_read_a);
 	});
 }
@@ -342,12 +342,12 @@ std::string nano::ipc::request (nano::ipc::payload_encoding encoding_a, nano::ip
 	auto res (std::make_shared<std::vector<uint8_t>> ());
 
 	std::promise<std::string> result_l;
-	ipc_client.async_write (req, [&ipc_client, &res, &result_l](nano::error err_a, size_t size_a) {
+	ipc_client.async_write (req, [&ipc_client, &res, &result_l] (nano::error err_a, size_t size_a) {
 		// Read length
-		ipc_client.async_read (res, sizeof (uint32_t), [&ipc_client, &res, &result_l](nano::error err_read_a, size_t size_read_a) {
+		ipc_client.async_read (res, sizeof (uint32_t), [&ipc_client, &res, &result_l] (nano::error err_read_a, size_t size_read_a) {
 			uint32_t payload_size_l = boost::endian::big_to_native (*reinterpret_cast<uint32_t *> (res->data ()));
 			// Read json payload
-			ipc_client.async_read (res, payload_size_l, [&res, &result_l](nano::error err_read_a, size_t size_read_a) {
+			ipc_client.async_read (res, payload_size_l, [&res, &result_l] (nano::error err_read_a, size_t size_read_a) {
 				result_l.set_value (std::string (res->begin (), res->end ()));
 			});
 		});
diff --git a/nano/lib/ipc_client.hpp b/nano/lib/ipc_client.hpp
index 6fde3cc7d1..b3f5f93e1a 100644
--- a/nano/lib/ipc_client.hpp
+++ b/nano/lib/ipc_client.hpp
@@ -38,13 +38,13 @@ namespace ipc
 		nano::error connect (std::string const & host, uint16_t port);
 
 		/** Connect to a tcp socket asynchronously */
-		void async_connect (std::string const & host, uint16_t port, std::function<void(nano::error)> callback);
+		void async_connect (std::string const & host, uint16_t port, std::function<void (nano::error)> callback);
 
 		/** Write buffer asynchronously */
-		void async_write (nano::shared_const_buffer const & buffer_a, std::function<void(nano::error, size_t)> callback_a);
+		void async_write (nano::shared_const_buffer const & buffer_a, std::function<void (nano::error, size_t)> callback_a);
 
 		/** Read \p size_a bytes asynchronously */
-		void async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void(nano::error, size_t)> callback_a);
+		void async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void (nano::error, size_t)> callback_a);
 
 		/**
 		 * Read a length-prefixed message asynchronously using the given timeout. This is suitable for full duplex scenarios where it may
@@ -54,7 +54,7 @@ namespace ipc
 		 * @param timeout_a How long to await message data. In some scenarios, such as waiting for data on subscriptions, specifying std::chrono::seconds::max() makes sense.
 		 * @param callback_a If called without errors, the payload buffer is successfully populated
 		 */
-		void async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void(nano::error, size_t)> callback_a);
+		void async_read_message (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, std::chrono::seconds timeout_a, std::function<void (nano::error, size_t)> callback_a);
 
 	private:
 		boost::asio::io_context & io_ctx;
diff --git a/nano/lib/json_error_response.hpp b/nano/lib/json_error_response.hpp
index 315dc917d1..6bb4f23774 100644
--- a/nano/lib/json_error_response.hpp
+++ b/nano/lib/json_error_response.hpp
@@ -5,7 +5,7 @@
 
 namespace nano
 {
-inline void json_error_response (std::function<void(std::string const &)> response_a, std::string const & message_a)
+inline void json_error_response (std::function<void (std::string const &)> response_a, std::string const & message_a)
 {
 	boost::property_tree::ptree response_l;
 	response_l.put ("error", message_a);
diff --git a/nano/lib/jsonconfig.cpp b/nano/lib/jsonconfig.cpp
index 9c054536e3..90547ecb15 100644
--- a/nano/lib/jsonconfig.cpp
+++ b/nano/lib/jsonconfig.cpp
@@ -7,13 +7,13 @@
 #include <cstddef>
 
 nano::jsonconfig::jsonconfig () :
-tree (tree_default)
+	tree (tree_default)
 {
 	error = std::make_shared<nano::error> ();
 }
 
 nano::jsonconfig::jsonconfig (boost::property_tree::ptree & tree_a, std::shared_ptr<nano::error> const & error_a) :
-nano::configbase (error_a), tree (tree_a)
+	nano::configbase (error_a), tree (tree_a)
 {
 	if (!error)
 	{
@@ -192,7 +192,7 @@ nano::jsonconfig & nano::jsonconfig::get_config (bool optional, std::string key,
 
 nano::jsonconfig & nano::jsonconfig::get_config (bool optional, std::string key, bool & target, bool default_value)
 {
-	auto bool_conv = [this, &target, &key, optional](std::string val) {
+	auto bool_conv = [this, &target, &key, optional] (std::string val) {
 		if (val == "true")
 		{
 			target = true;
diff --git a/nano/lib/jsonconfig.hpp b/nano/lib/jsonconfig.hpp
index 116a48424d..258986fa28 100644
--- a/nano/lib/jsonconfig.hpp
+++ b/nano/lib/jsonconfig.hpp
@@ -101,7 +101,7 @@ class jsonconfig : public nano::configbase
 
 	/** Iterate array entries */
 	template <typename T>
-	jsonconfig & array_entries (std::function<void(T)> callback)
+	jsonconfig & array_entries (std::function<void (T)> callback)
 	{
 		for (auto & entry : tree)
 		{
diff --git a/nano/lib/locks.cpp b/nano/lib/locks.cpp
index a11deca3f1..6d487db210 100644
--- a/nano/lib/locks.cpp
+++ b/nano/lib/locks.cpp
@@ -19,7 +19,7 @@ void output (const char * str, std::chrono::milliseconds time, Mutex & mutex)
 	// Guard standard out to keep the output from being interleaved
 	std::lock_guard guard (cout_mutex);
 	std::cout << (boost::format ("%1% Mutex %2% %3% for %4%ms\n%5%") % std::addressof (mutex) % mutex.get_name () % str % time.count () % stacktrace).str ()
-	          << std::endl;
+			  << std::endl;
 }
 
 template <typename Mutex>
@@ -59,7 +59,7 @@ void output_if_blocked_long_enough (nano::timer<std::chrono::milliseconds> & tim
 #endif
 
 lock_guard<nano::mutex>::lock_guard (nano::mutex & mutex) :
-mut (mutex)
+	mut (mutex)
 {
 	timer.start ();
 
@@ -77,14 +77,14 @@ lock_guard<nano::mutex>::~lock_guard () noexcept
 
 template <typename Mutex, typename U>
 unique_lock<Mutex, U>::unique_lock (Mutex & mutex) :
-mut (std::addressof (mutex))
+	mut (std::addressof (mutex))
 {
 	lock_impl ();
 }
 
 template <typename Mutex, typename U>
 unique_lock<Mutex, U>::unique_lock (Mutex & mutex, std::defer_lock_t) noexcept :
-mut (std::addressof (mutex))
+	mut (std::addressof (mutex))
 {
 }
 
diff --git a/nano/lib/locks.hpp b/nano/lib/locks.hpp
index c7b725cd51..ef1217b36f 100644
--- a/nano/lib/locks.hpp
+++ b/nano/lib/locks.hpp
@@ -47,8 +47,8 @@ class mutex
 	mutex () = default;
 	mutex (const char * name_a)
 #if USING_NANO_TIMED_LOCKS
-	:
-	name (name_a)
+		:
+		name (name_a)
 #endif
 	{
 #if USING_NANO_TIMED_LOCKS
@@ -120,7 +120,7 @@ class lock_guard final
 {
 public:
 	explicit lock_guard (Mutex & mutex_a) :
-	guard (mutex_a)
+		guard (mutex_a)
 	{
 	}
 
@@ -266,14 +266,14 @@ class locked
 
 	template <typename... Args>
 	locked (Args &&... args) :
-	obj (std::forward<Args> (args)...)
+		obj (std::forward<Args> (args)...)
 	{
 	}
 
 	struct scoped_lock final
 	{
 		scoped_lock (locked * owner_a) :
-		owner (owner_a)
+			owner (owner_a)
 		{
 			owner->mutex.lock ();
 		}
diff --git a/nano/lib/logger_mt.hpp b/nano/lib/logger_mt.hpp
index b6e0183c2c..eff7d4d297 100644
--- a/nano/lib/logger_mt.hpp
+++ b/nano/lib/logger_mt.hpp
@@ -75,7 +75,7 @@ class logger_mt
 	 * @param min_log_delta_a The minimum time between successive output
 	 */
 	explicit logger_mt (std::chrono::milliseconds const & min_log_delta_a) :
-	min_log_delta (min_log_delta_a)
+		min_log_delta (min_log_delta_a)
 	{
 	}
 
diff --git a/nano/lib/memory.cpp b/nano/lib/memory.cpp
index ad61766c85..b676aa0a1a 100644
--- a/nano/lib/memory.cpp
+++ b/nano/lib/memory.cpp
@@ -23,8 +23,8 @@ void nano::set_use_memory_pools (bool use_memory_pools_a)
 #endif
 }
 
-nano::cleanup_guard::cleanup_guard (std::vector<std::function<void()>> const & cleanup_funcs_a) :
-cleanup_funcs (cleanup_funcs_a)
+nano::cleanup_guard::cleanup_guard (std::vector<std::function<void ()>> const & cleanup_funcs_a) :
+	cleanup_funcs (cleanup_funcs_a)
 {
 }
 
diff --git a/nano/lib/memory.hpp b/nano/lib/memory.hpp
index f51945f8a4..6a484540d3 100644
--- a/nano/lib/memory.hpp
+++ b/nano/lib/memory.hpp
@@ -41,11 +41,11 @@ bool purge_shared_ptr_singleton_pool_memory ()
 class cleanup_guard final
 {
 public:
-	cleanup_guard (std::vector<std::function<void()>> const & cleanup_funcs_a);
+	cleanup_guard (std::vector<std::function<void ()>> const & cleanup_funcs_a);
 	~cleanup_guard ();
 
 private:
-	std::vector<std::function<void()>> cleanup_funcs;
+	std::vector<std::function<void ()>> cleanup_funcs;
 };
 
 template <typename T, typename... Args>
diff --git a/nano/lib/numbers.cpp b/nano/lib/numbers.cpp
index 45d646e8e0..2798cc96be 100644
--- a/nano/lib/numbers.cpp
+++ b/nano/lib/numbers.cpp
@@ -782,7 +782,7 @@ std::string nano::uint128_union::to_string_dec () const
 }
 
 nano::hash_or_account::hash_or_account (uint64_t value_a) :
-raw (value_a)
+	raw (value_a)
 {
 }
 
diff --git a/nano/lib/optional_ptr.hpp b/nano/lib/optional_ptr.hpp
index 7c7ab903c8..56695fc3ed 100644
--- a/nano/lib/optional_ptr.hpp
+++ b/nano/lib/optional_ptr.hpp
@@ -24,7 +24,7 @@ class optional_ptr
 	optional_ptr () = default;
 
 	optional_ptr (T const & value) :
-	ptr (new T{ value })
+		ptr (new T{ value })
 	{
 	}
 
diff --git a/nano/lib/rpc_handler_interface.hpp b/nano/lib/rpc_handler_interface.hpp
index 2679017f49..c5a5dba86c 100644
--- a/nano/lib/rpc_handler_interface.hpp
+++ b/nano/lib/rpc_handler_interface.hpp
@@ -57,9 +57,9 @@ class rpc_handler_interface
 public:
 	virtual ~rpc_handler_interface () = default;
 	/** Process RPC 1.0 request. */
-	virtual void process_request (std::string const & action, std::string const & body, std::function<void(std::string const &)> response) = 0;
+	virtual void process_request (std::string const & action, std::string const & body, std::function<void (std::string const &)> response) = 0;
 	/** Process RPC 2.0 request. This is called via the IPC API */
-	virtual void process_request_v2 (rpc_handler_request_params const & params_a, std::string const & body, std::function<void(std::shared_ptr<std::string> const &)> response) = 0;
+	virtual void process_request_v2 (rpc_handler_request_params const & params_a, std::string const & body, std::function<void (std::shared_ptr<std::string> const &)> response) = 0;
 	virtual void stop () = 0;
 	virtual void rpc_instance (nano::rpc & rpc) = 0;
 };
diff --git a/nano/lib/rpcconfig.cpp b/nano/lib/rpcconfig.cpp
index e2194ad7df..b74d2aded2 100644
--- a/nano/lib/rpcconfig.cpp
+++ b/nano/lib/rpcconfig.cpp
@@ -55,14 +55,14 @@ nano::error nano::rpc_secure_config::deserialize_toml (nano::tomlconfig & toml)
 }
 
 nano::rpc_config::rpc_config () :
-address (boost::asio::ip::address_v6::loopback ().to_string ())
+	address (boost::asio::ip::address_v6::loopback ().to_string ())
 {
 }
 
 nano::rpc_config::rpc_config (uint16_t port_a, bool enable_control_a) :
-address (boost::asio::ip::address_v6::loopback ().to_string ()),
-port (port_a),
-enable_control (enable_control_a)
+	address (boost::asio::ip::address_v6::loopback ().to_string ()),
+	port (port_a),
+	enable_control (enable_control_a)
 {
 }
 
@@ -184,7 +184,7 @@ nano::error nano::rpc_config::deserialize_toml (nano::tomlconfig & toml)
 }
 
 nano::rpc_process_config::rpc_process_config () :
-ipc_address (boost::asio::ip::address_v6::loopback ().to_string ())
+	ipc_address (boost::asio::ip::address_v6::loopback ().to_string ())
 {
 }
 
@@ -200,8 +200,8 @@ nano::error read_rpc_config_toml (boost::filesystem::path const & data_path_a, n
 		if (boost::filesystem::exists (toml_config_path))
 		{
 			error = "Both json and toml rpc configuration files exists. "
-			        "Either remove the config.json file and restart, or remove "
-			        "the config-rpc.toml file to start migration on next launch.";
+					"Either remove the config.json file and restart, or remove "
+					"the config-rpc.toml file to start migration on next launch.";
 		}
 		else
 		{
diff --git a/nano/lib/stats.cpp b/nano/lib/stats.cpp
index 27d29cefdd..1732d428a4 100644
--- a/nano/lib/stats.cpp
+++ b/nano/lib/stats.cpp
@@ -175,7 +175,7 @@ class file_writer : public nano::stat_log_sink
 	std::string filename;
 
 	explicit file_writer (std::string const & filename) :
-	filename (filename)
+		filename (filename)
 	{
 		log.open (filename.c_str (), std::ofstream::out);
 	}
@@ -283,7 +283,7 @@ std::vector<nano::stat_histogram::bin> nano::stat_histogram::get_bins () const
 }
 
 nano::stat::stat (nano::stat_config config) :
-config (config)
+	config (config)
 {
 }
 
diff --git a/nano/lib/stats.hpp b/nano/lib/stats.hpp
index cf4865630d..14412abdab 100644
--- a/nano/lib/stats.hpp
+++ b/nano/lib/stats.hpp
@@ -98,7 +98,7 @@ class stat_histogram final
 	{
 	public:
 		bin (uint64_t start_inclusive_a, uint64_t end_exclusive_a) :
-		start_inclusive (start_inclusive_a), end_exclusive (end_exclusive_a)
+			start_inclusive (start_inclusive_a), end_exclusive (end_exclusive_a)
 		{
 		}
 		uint64_t start_inclusive;
@@ -120,7 +120,7 @@ class stat_entry final
 {
 public:
 	stat_entry (size_t capacity, size_t interval) :
-	samples (capacity), sample_interval (interval)
+		samples (capacity), sample_interval (interval)
 	{
 	}
 
@@ -516,12 +516,12 @@ class stat final
 	 * To avoid recursion, the observer callback must only use the received data point snapshop, not query the stat object.
 	 * @param observer The observer receives a snapshot of the current samples.
 	 */
-	void observe_sample (stat::type type, stat::detail detail, stat::dir dir, std::function<void(boost::circular_buffer<stat_datapoint> &)> observer)
+	void observe_sample (stat::type type, stat::detail detail, stat::dir dir, std::function<void (boost::circular_buffer<stat_datapoint> &)> observer)
 	{
 		get_entry (key_of (type, detail, dir))->sample_observers.add (observer);
 	}
 
-	void observe_sample (stat::type type, stat::dir dir, std::function<void(boost::circular_buffer<stat_datapoint> &)> observer)
+	void observe_sample (stat::type type, stat::dir dir, std::function<void (boost::circular_buffer<stat_datapoint> &)> observer)
 	{
 		observe_sample (type, stat::detail::all, dir, observer);
 	}
@@ -531,7 +531,7 @@ class stat final
 	 * To avoid recursion, the observer callback must only use the received counts, not query the stat object.
 	 * @param observer The observer receives the old and the new count.
 	 */
-	void observe_count (stat::type type, stat::detail detail, stat::dir dir, std::function<void(uint64_t, uint64_t)> observer)
+	void observe_count (stat::type type, stat::detail detail, stat::dir dir, std::function<void (uint64_t, uint64_t)> observer)
 	{
 		get_entry (key_of (type, detail, dir))->count_observers.add (observer);
 	}
diff --git a/nano/lib/threading.cpp b/nano/lib/threading.cpp
index e11330c233..05cdb87514 100644
--- a/nano/lib/threading.cpp
+++ b/nano/lib/threading.cpp
@@ -120,14 +120,14 @@ void nano::thread_attributes::set (boost::thread::attributes & attrs)
 }
 
 nano::thread_runner::thread_runner (boost::asio::io_context & io_ctx_a, unsigned service_threads_a) :
-io_guard (boost::asio::make_work_guard (io_ctx_a))
+	io_guard (boost::asio::make_work_guard (io_ctx_a))
 {
 	boost::thread::attributes attrs;
 	nano::thread_attributes::set (attrs);
 	auto count = (is_sanitizer_build && nano::network_constants{}.is_dev_network ()) ? 1 : service_threads_a; // This is a workaround to a bad interaction between TSAN, multiple coroutines, and multiple threads servicing io_context. Only use 1 thread if sanitizers are attached
 	for (auto i (0u); i < count; ++i)
 	{
-		threads.emplace_back (attrs, [&io_ctx_a]() {
+		threads.emplace_back (attrs, [&io_ctx_a] () {
 			nano::thread_role::set (nano::thread_role::name::io);
 			try
 			{
@@ -197,8 +197,8 @@ void nano::thread_runner::stop_event_processing ()
 }
 
 nano::thread_pool::thread_pool (unsigned num_threads, nano::thread_role::name thread_name) :
-num_threads (num_threads),
-thread_pool_m (std::make_unique<boost::asio::thread_pool> (num_threads))
+	num_threads (num_threads),
+	thread_pool_m (std::make_unique<boost::asio::thread_pool> (num_threads))
 {
 	set_thread_names (num_threads, thread_name);
 }
@@ -226,26 +226,26 @@ void nano::thread_pool::stop ()
 	}
 }
 
-void nano::thread_pool::push_task (std::function<void()> task)
+void nano::thread_pool::push_task (std::function<void ()> task)
 {
 	++num_tasks;
 	nano::lock_guard<nano::mutex> guard (mutex);
 	if (!stopped)
 	{
-		boost::asio::post (*thread_pool_m, [this, task]() {
+		boost::asio::post (*thread_pool_m, [this, task] () {
 			task ();
 			--num_tasks;
 		});
 	}
 }
 
-void nano::thread_pool::add_timed_task (std::chrono::steady_clock::time_point const & expiry_time, std::function<void()> task)
+void nano::thread_pool::add_timed_task (std::chrono::steady_clock::time_point const & expiry_time, std::function<void ()> task)
 {
 	nano::lock_guard<nano::mutex> guard (mutex);
 	if (!stopped && thread_pool_m)
 	{
 		auto timer = std::make_shared<boost::asio::steady_timer> (thread_pool_m->get_executor (), expiry_time);
-		timer->async_wait ([this, task, timer](const boost::system::error_code & ec) {
+		timer->async_wait ([this, task, timer] (const boost::system::error_code & ec) {
 			if (!ec)
 			{
 				push_task (task);
@@ -270,13 +270,13 @@ void nano::thread_pool::set_thread_names (unsigned num_threads, nano::thread_rol
 	std::vector<std::promise<void>> promises (num_threads);
 	std::vector<std::future<void>> futures;
 	futures.reserve (num_threads);
-	std::transform (promises.begin (), promises.end (), std::back_inserter (futures), [](auto & promise) {
+	std::transform (promises.begin (), promises.end (), std::back_inserter (futures), [] (auto & promise) {
 		return promise.get_future ();
 	});
 
 	for (auto i = 0u; i < num_threads; ++i)
 	{
-		boost::asio::post (*thread_pool_m, [& promise = promises[i], thread_name]() {
+		boost::asio::post (*thread_pool_m, [&promise = promises[i], thread_name] () {
 			nano::thread_role::set (thread_name);
 			promise.set_value ();
 		});
@@ -292,6 +292,6 @@ void nano::thread_pool::set_thread_names (unsigned num_threads, nano::thread_rol
 std::unique_ptr<nano::container_info_component> nano::collect_container_info (thread_pool & thread_pool, std::string const & name)
 {
 	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "count", thread_pool.num_queued_tasks (), sizeof (std::function<void()>) }));
+	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "count", thread_pool.num_queued_tasks (), sizeof (std::function<void ()>) }));
 	return composite;
 }
diff --git a/nano/lib/threading.hpp b/nano/lib/threading.hpp
index 955c8798ff..3a6478f87b 100644
--- a/nano/lib/threading.hpp
+++ b/nano/lib/threading.hpp
@@ -90,7 +90,7 @@ class relaxed_atomic_integral
 public:
 	relaxed_atomic_integral () noexcept = default;
 	constexpr relaxed_atomic_integral (T desired) noexcept :
-	atomic (desired)
+		atomic (desired)
 	{
 	}
 
@@ -169,10 +169,10 @@ class thread_pool final
 	~thread_pool ();
 
 	/** This will run when there is an available thread for execution */
-	void push_task (std::function<void()>);
+	void push_task (std::function<void ()>);
 
 	/** Run a task at a certain point in time */
-	void add_timed_task (std::chrono::steady_clock::time_point const & expiry_time, std::function<void()> task);
+	void add_timed_task (std::chrono::steady_clock::time_point const & expiry_time, std::function<void ()> task);
 
 	/** Stops any further pushed tasks from executing */
 	void stop ();
diff --git a/nano/lib/timer.cpp b/nano/lib/timer.cpp
index 90b454c48b..9357f885de 100644
--- a/nano/lib/timer.cpp
+++ b/nano/lib/timer.cpp
@@ -45,7 +45,7 @@ std::string typed_unit ()
 
 template <typename UNIT, typename CLOCK>
 nano::timer<UNIT, CLOCK>::timer (nano::timer_state state_a, std::string const & description_a) :
-desc (description_a)
+	desc (description_a)
 {
 	if (state_a == nano::timer_state::started)
 	{
@@ -55,14 +55,14 @@ desc (description_a)
 
 template <typename UNIT, typename CLOCK>
 nano::timer<UNIT, CLOCK>::timer (std::string const & description_a) :
-desc (description_a)
+	desc (description_a)
 {
 }
 
 template <typename UNIT, typename CLOCK>
 nano::timer<UNIT, CLOCK>::timer (std::string const & description_a, nano::timer<UNIT, CLOCK> * parent_a) :
-parent (parent_a),
-desc (description_a)
+	parent (parent_a),
+	desc (description_a)
 {
 }
 
diff --git a/nano/lib/tomlconfig.cpp b/nano/lib/tomlconfig.cpp
index 7a701f2f7a..12cea9b3de 100644
--- a/nano/lib/tomlconfig.cpp
+++ b/nano/lib/tomlconfig.cpp
@@ -4,13 +4,13 @@
 #include <boost/filesystem/convenience.hpp>
 
 nano::tomlconfig::tomlconfig () :
-tree (cpptoml::make_table ())
+	tree (cpptoml::make_table ())
 {
 	error = std::make_shared<nano::error> ();
 }
 
 nano::tomlconfig::tomlconfig (std::shared_ptr<cpptoml::table> const & tree_a, std::shared_ptr<nano::error> const & error_a) :
-nano::configbase (error_a), tree (tree_a)
+	nano::configbase (error_a), tree (tree_a)
 {
 	if (!error)
 	{
@@ -250,7 +250,7 @@ nano::tomlconfig & nano::tomlconfig::get_config (bool optional, std::string cons
 
 nano::tomlconfig & nano::tomlconfig::get_config (bool optional, std::string const & key, bool & target, bool default_value)
 {
-	auto bool_conv = [this, &target, &key, optional](std::string val) {
+	auto bool_conv = [this, &target, &key, optional] (std::string val) {
 		if (val == "true")
 		{
 			target = true;
@@ -317,7 +317,7 @@ void nano::tomlconfig::erase_defaults (std::shared_ptr<cpptoml::table> const & b
 				if (arr_other.size () == arr_base.size ())
 				{
 					bool equal = std::equal (arr_other.begin (), arr_other.end (), arr_base.begin (),
-					[](auto const & item1, auto const & item2) -> bool {
+					[] (auto const & item1, auto const & item2) -> bool {
 						return (item1->template as<std::string> ()->get () == item2->template as<std::string> ()->get ());
 					});
 
diff --git a/nano/lib/tomlconfig.hpp b/nano/lib/tomlconfig.hpp
index 0f4436bbf4..20c03e6062 100644
--- a/nano/lib/tomlconfig.hpp
+++ b/nano/lib/tomlconfig.hpp
@@ -85,7 +85,7 @@ class tomlconfig : public nano::configbase
 	 * @param key Array element key. Qualified (dotted) keys are not supported for arrays so this must be called on the correct tomlconfig node.
 	 */
 	template <typename T>
-	tomlconfig & array_entries_required (std::string const & key, std::function<void(T)> callback)
+	tomlconfig & array_entries_required (std::string const & key, std::function<void (T)> callback)
 	{
 		if (tree->contains_qualified (key))
 		{
diff --git a/nano/lib/utility.cpp b/nano/lib/utility.cpp
index e507cc65b9..e6dd666b5a 100644
--- a/nano/lib/utility.cpp
+++ b/nano/lib/utility.cpp
@@ -49,7 +49,7 @@ std::size_t nano::get_filedescriptor_limit ()
 }
 
 nano::container_info_composite::container_info_composite (std::string const & name) :
-name (name)
+	name (name)
 {
 }
 
@@ -74,7 +74,7 @@ const std::string & nano::container_info_composite::get_name () const
 }
 
 nano::container_info_leaf::container_info_leaf (const container_info & info) :
-info (info)
+	info (info)
 {
 }
 
@@ -131,8 +131,8 @@ void nano::move_all_files_to_dir (boost::filesystem::path const & from, boost::f
 void assert_internal (const char * check_expr, const char * func, const char * file, unsigned int line, bool is_release_assert, std::string_view error_msg)
 {
 	std::cerr << "Assertion (" << check_expr << ") failed\n"
-	          << func << "\n"
-	          << file << ":" << line << "\n";
+			  << func << "\n"
+			  << file << ":" << line << "\n";
 	if (!error_msg.empty ())
 	{
 		std::cerr << "Error: " << error_msg << "\n";
diff --git a/nano/lib/utility.hpp b/nano/lib/utility.hpp
index d175c0b93b..db8e2c35d3 100644
--- a/nano/lib/utility.hpp
+++ b/nano/lib/utility.hpp
@@ -146,7 +146,7 @@ template <typename... T>
 class observer_set final
 {
 public:
-	void add (std::function<void(T...)> const & observer_a)
+	void add (std::function<void (T...)> const & observer_a)
 	{
 		nano::lock_guard<nano::mutex> lock (mutex);
 		observers.push_back (observer_a);
@@ -160,7 +160,7 @@ class observer_set final
 		}
 	}
 	nano::mutex mutex{ mutex_identifier (mutexes::observer_set) };
-	std::vector<std::function<void(T...)>> observers;
+	std::vector<std::function<void (T...)>> observers;
 };
 
 template <typename... T>
diff --git a/nano/lib/work.cpp b/nano/lib/work.cpp
index d88db09a0d..6ccf06174e 100644
--- a/nano/lib/work.cpp
+++ b/nano/lib/work.cpp
@@ -199,10 +199,10 @@ double nano::denormalized_multiplier (double const multiplier_a, uint64_t const
 }
 
 nano::work_pool::work_pool (unsigned max_threads_a, std::chrono::nanoseconds pow_rate_limiter_a, std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> opencl_a) :
-ticket (0),
-done (false),
-pow_rate_limiter (pow_rate_limiter_a),
-opencl (opencl_a)
+	ticket (0),
+	done (false),
+	pow_rate_limiter (pow_rate_limiter_a),
+	opencl (opencl_a)
 {
 	static_assert (ATOMIC_INT_LOCK_FREE == 2, "Atomic int needed");
 	boost::thread::attributes attrs;
@@ -215,7 +215,7 @@ opencl (opencl_a)
 	}
 	for (auto i (0u); i < count; ++i)
 	{
-		threads.emplace_back (attrs, [this, i]() {
+		threads.emplace_back (attrs, [this, i] () {
 			nano::thread_role::set (nano::thread_role::name::work);
 			nano::work_thread_reprioritize ();
 			loop (i);
@@ -331,7 +331,7 @@ void nano::work_pool::cancel (nano::root const & root_a)
 				++ticket;
 			}
 		}
-		pending.remove_if ([&root_a](decltype (pending)::value_type const & item_a) {
+		pending.remove_if ([&root_a] (decltype (pending)::value_type const & item_a) {
 			bool result{ false };
 			if (item_a.item == root_a)
 			{
@@ -356,7 +356,7 @@ void nano::work_pool::stop ()
 	producer_condition.notify_all ();
 }
 
-void nano::work_pool::generate (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::function<void(boost::optional<uint64_t> const &)> callback_a)
+void nano::work_pool::generate (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::function<void (boost::optional<uint64_t> const &)> callback_a)
 {
 	debug_assert (!root_a.is_zero ());
 	if (!threads.empty ())
@@ -394,7 +394,7 @@ boost::optional<uint64_t> nano::work_pool::generate (nano::work_version const ve
 	{
 		std::promise<boost::optional<uint64_t>> work;
 		std::future<boost::optional<uint64_t>> future = work.get_future ();
-		generate (version_a, root_a, difficulty_a, [&work](boost::optional<uint64_t> work_a) {
+		generate (version_a, root_a, difficulty_a, [&work] (boost::optional<uint64_t> work_a) {
 			work.set_value (work_a);
 		});
 		result = future.get ().value ();
diff --git a/nano/lib/work.hpp b/nano/lib/work.hpp
index db4a35b9d3..6480357d11 100644
--- a/nano/lib/work.hpp
+++ b/nano/lib/work.hpp
@@ -47,14 +47,14 @@ class opencl_work;
 class work_item final
 {
 public:
-	work_item (nano::work_version const version_a, nano::root const & item_a, uint64_t difficulty_a, std::function<void(boost::optional<uint64_t> const &)> const & callback_a) :
-	version (version_a), item (item_a), difficulty (difficulty_a), callback (callback_a)
+	work_item (nano::work_version const version_a, nano::root const & item_a, uint64_t difficulty_a, std::function<void (boost::optional<uint64_t> const &)> const & callback_a) :
+		version (version_a), item (item_a), difficulty (difficulty_a), callback (callback_a)
 	{
 	}
 	nano::work_version const version;
 	nano::root const item;
 	uint64_t const difficulty;
-	std::function<void(boost::optional<uint64_t> const &)> const callback;
+	std::function<void (boost::optional<uint64_t> const &)> const callback;
 };
 class work_pool final
 {
@@ -64,7 +64,7 @@ class work_pool final
 	void loop (uint64_t);
 	void stop ();
 	void cancel (nano::root const &);
-	void generate (nano::work_version const, nano::root const &, uint64_t, std::function<void(boost::optional<uint64_t> const &)>);
+	void generate (nano::work_version const, nano::root const &, uint64_t, std::function<void (boost::optional<uint64_t> const &)>);
 	boost::optional<uint64_t> generate (nano::work_version const, nano::root const &, uint64_t);
 	// For tests only
 	boost::optional<uint64_t> generate (nano::root const &);
diff --git a/nano/load_test/entry.cpp b/nano/load_test/entry.cpp
index 03e1577ae1..e64b096cd4 100644
--- a/nano/load_test/entry.cpp
+++ b/nano/load_test/entry.cpp
@@ -163,7 +163,7 @@ boost::property_tree::ptree rpc_request (boost::property_tree::ptree const & req
 	debug_assert (results.size () == 1);
 
 	std::promise<boost::optional<boost::property_tree::ptree>> promise;
-	boost::asio::spawn (ioc, [&ioc, &results, request, &promise](boost::asio::yield_context yield) {
+	boost::asio::spawn (ioc, [&ioc, &results, request, &promise] (boost::asio::yield_context yield) {
 		socket_type socket (ioc);
 		boost::beast::flat_buffer buffer;
 		http::request<http::string_body> req;
@@ -377,7 +377,7 @@ int main (int argc, char * const * argv)
 	boost::asio::io_context ioc;
 
 	debug_assert (!nano::signal_handler_impl);
-	nano::signal_handler_impl = [&ioc]() {
+	nano::signal_handler_impl = [&ioc] () {
 		ioc.stop ();
 	};
 
@@ -387,7 +387,7 @@ int main (int argc, char * const * argv)
 	tcp::resolver resolver{ ioc };
 	auto const primary_node_results = resolver.resolve ("::1", std::to_string (rpc_port_start));
 
-	std::thread t ([send_count, &ioc, &primary_node_results, &resolver, &node_count, &destination_count]() {
+	std::thread t ([send_count, &ioc, &primary_node_results, &resolver, &node_count, &destination_count] () {
 		for (int i = 0; i < node_count; ++i)
 		{
 			keepalive_rpc (ioc, primary_node_results, peering_port_start + i);
@@ -436,7 +436,7 @@ int main (int argc, char * const * argv)
 			}
 
 			// Send from genesis account to different accounts and receive the funds
-			boost::asio::spawn (ioc, [&ioc, &primary_node_results, &wallet, destination_account, &send_calls_remaining](boost::asio::yield_context yield) {
+			boost::asio::spawn (ioc, [&ioc, &primary_node_results, &wallet, destination_account, &send_calls_remaining] (boost::asio::yield_context yield) {
 				send_receive (ioc, wallet, nano::genesis_account.to_account (), destination_account->as_string, send_calls_remaining, primary_node_results, yield);
 			});
 		}
diff --git a/nano/nano_node/daemon.cpp b/nano/nano_node/daemon.cpp
index 86c5c31ad9..b2dc93f330 100644
--- a/nano/nano_node/daemon.cpp
+++ b/nano/nano_node/daemon.cpp
@@ -51,10 +51,10 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano::
 		nano::logger_mt logger{ config.node.logging.min_time_between_log_output };
 		boost::asio::io_context io_ctx;
 		auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger));
-		nano::work_pool opencl_work (config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl](nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> & ticket_a) {
+		nano::work_pool opencl_work (config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> & ticket_a) {
 			return opencl->generate_work (version_a, root_a, difficulty_a, ticket_a);
 		}
-		                                                                                              : std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> (nullptr));
+																									  : std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> (nullptr));
 		try
 		{
 			// This avoid a blank prompt during any node initialization delays
@@ -76,9 +76,9 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano::
 			{
 				auto network_label = node->network_params.network.get_current_network_as_string ();
 				std::cout << "Network: " << network_label << ", version: " << NANO_VERSION_STRING << "\n"
-				          << "Path: " << node->application_path.string () << "\n"
-				          << "Build Info: " << BUILD_INFO << "\n"
-				          << "Database backend: " << node->store.vendor_get () << std::endl;
+						  << "Path: " << node->application_path.string () << "\n"
+						  << "Build Info: " << BUILD_INFO << "\n"
+						  << "Database backend: " << node->store.vendor_get () << std::endl;
 				auto voting (node->wallets.reps ().voting);
 				if (voting > 1)
 				{
@@ -114,9 +114,9 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano::
 							std::cout << error.get_message () << std::endl;
 							std::exit (1);
 						}
-						rpc_handler = std::make_unique<nano::inprocess_rpc_handler> (*node, ipc_server, config.rpc, [&ipc_server, &workers = node->workers, &io_ctx]() {
+						rpc_handler = std::make_unique<nano::inprocess_rpc_handler> (*node, ipc_server, config.rpc, [&ipc_server, &workers = node->workers, &io_ctx] () {
 							ipc_server.stop ();
-							workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (3), [&io_ctx]() {
+							workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (3), [&io_ctx] () {
 								io_ctx.stop ();
 							});
 						});
@@ -137,7 +137,7 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano::
 				}
 
 				debug_assert (!nano::signal_handler_impl);
-				nano::signal_handler_impl = [&io_ctx]() {
+				nano::signal_handler_impl = [&io_ctx] () {
 					io_ctx.stop ();
 					sig_int_or_term = 1;
 				};
diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp
index bd6b17a60e..5a1c24b6a9 100644
--- a/nano/nano_node/entry.cpp
+++ b/nano/nano_node/entry.cpp
@@ -172,8 +172,8 @@ int main (int argc, char * const * argv)
 				auto const ledger_unfiltered = node->ledger.cache.rep_weights.get_rep_amounts ();
 				auto const ledger_height = node->ledger.cache.block_count.load ();
 
-				auto get_total = [](decltype (bootstrap_weights.second) const & reps) -> nano::uint128_union {
-					return std::accumulate (reps.begin (), reps.end (), nano::uint128_t{ 0 }, [](auto sum, auto const & rep) { return sum + rep.second; });
+				auto get_total = [] (decltype (bootstrap_weights.second) const & reps) -> nano::uint128_union {
+					return std::accumulate (reps.begin (), reps.end (), nano::uint128_t{ 0 }, [] (auto sum, auto const & rep) { return sum + rep.second; });
 				};
 
 				// Hardcoded weights are filtered to a cummulative weight of 99%, need to do the same for ledger weights
@@ -182,7 +182,7 @@ int main (int argc, char * const * argv)
 					std::vector<std::pair<nano::account, nano::uint128_t>> sorted;
 					sorted.reserve (ledger_unfiltered.size ());
 					std::copy (ledger_unfiltered.begin (), ledger_unfiltered.end (), std::back_inserter (sorted));
-					std::sort (sorted.begin (), sorted.end (), [](auto const & left, auto const & right) { return left.second > right.second; });
+					std::sort (sorted.begin (), sorted.end (), [] (auto const & left, auto const & right) { return left.second > right.second; });
 					auto const total_unfiltered = get_total (ledger_unfiltered);
 					nano::uint128_t sum{ 0 };
 					auto target = (total_unfiltered.number () / 100) * 99;
@@ -210,7 +210,7 @@ int main (int argc, char * const * argv)
 
 				std::vector<mismatched_t> mismatched;
 				mismatched.reserve (hardcoded.size ());
-				std::transform (hardcoded.begin (), hardcoded.end (), std::back_inserter (mismatched), [&ledger](auto const & rep) {
+				std::transform (hardcoded.begin (), hardcoded.end (), std::back_inserter (mismatched), [&ledger] (auto const & rep) {
 					auto ledger_rep (ledger.find (rep.first));
 					nano::uint128_t ledger_weight = (ledger_rep == ledger.end () ? 0 : ledger_rep->second);
 					auto absolute = ledger_weight > rep.second ? ledger_weight - rep.second : rep.second - ledger_weight;
@@ -218,12 +218,12 @@ int main (int argc, char * const * argv)
 				});
 
 				// Sort by descending difference
-				std::sort (mismatched.begin (), mismatched.end (), [](mismatched_t const & left, mismatched_t const & right) { return left.diff > right.diff; });
+				std::sort (mismatched.begin (), mismatched.end (), [] (mismatched_t const & left, mismatched_t const & right) { return left.diff > right.diff; });
 
-				nano::uint128_union const mismatch_total = std::accumulate (mismatched.begin (), mismatched.end (), nano::uint128_t{ 0 }, [](auto sum, mismatched_t const & sample) { return sum + sample.diff.number (); });
+				nano::uint128_union const mismatch_total = std::accumulate (mismatched.begin (), mismatched.end (), nano::uint128_t{ 0 }, [] (auto sum, mismatched_t const & sample) { return sum + sample.diff.number (); });
 				nano::uint128_union const mismatch_mean = mismatch_total.number () / mismatched.size ();
 
-				nano::uint512_union mismatch_variance = std::accumulate (mismatched.begin (), mismatched.end (), nano::uint512_t (0), [M = mismatch_mean.number (), N = mismatched.size ()](nano::uint512_t sum, mismatched_t const & sample) {
+				nano::uint512_union mismatch_variance = std::accumulate (mismatched.begin (), mismatched.end (), nano::uint512_t (0), [M = mismatch_mean.number (), N = mismatched.size ()] (nano::uint512_t sum, mismatched_t const & sample) {
 					auto x = sample.diff.number ();
 					nano::uint512_t const mean_diff = x > M ? x - M : M - x;
 					nano::uint512_t const sqr = mean_diff * mean_diff;
@@ -235,20 +235,20 @@ int main (int argc, char * const * argv)
 
 				auto const outlier_threshold = std::max (nano::Gxrb_ratio, mismatch_mean.number () + 1 * mismatch_stddev.number ());
 				decltype (mismatched) outliers;
-				std::copy_if (mismatched.begin (), mismatched.end (), std::back_inserter (outliers), [outlier_threshold](mismatched_t const & sample) {
+				std::copy_if (mismatched.begin (), mismatched.end (), std::back_inserter (outliers), [outlier_threshold] (mismatched_t const & sample) {
 					return sample.diff > outlier_threshold;
 				});
 
 				auto const newcomer_threshold = std::max (nano::Gxrb_ratio, mismatch_mean.number ());
 				std::vector<std::pair<nano::account, nano::uint128_t>> newcomers;
-				std::copy_if (ledger.begin (), ledger.end (), std::back_inserter (newcomers), [&hardcoded](auto const & rep) {
+				std::copy_if (ledger.begin (), ledger.end (), std::back_inserter (newcomers), [&hardcoded] (auto const & rep) {
 					return !hardcoded.count (rep.first) && rep.second;
 				});
 
 				// Sort by descending weight
-				std::sort (newcomers.begin (), newcomers.end (), [](auto const & left, auto const & right) { return left.second > right.second; });
+				std::sort (newcomers.begin (), newcomers.end (), [] (auto const & left, auto const & right) { return left.second > right.second; });
 
-				auto newcomer_entry = [](auto const & rep) {
+				auto newcomer_entry = [] (auto const & rep) {
 					return boost::str (boost::format ("representative %1% hardcoded --- ledger %2%") % rep.first.to_account () % nano::uint128_union (rep.second).format_balance (nano::Mxrb_ratio, 0, true));
 				};
 
@@ -326,18 +326,18 @@ int main (int argc, char * const * argv)
 					nano::keypair genesis (key.to_string ());
 					nano::work_pool work (std::numeric_limits<unsigned>::max ());
 					std::cout << "Genesis: " << genesis.prv.to_string () << "\n"
-					          << "Public: " << genesis.pub.to_string () << "\n"
-					          << "Account: " << genesis.pub.to_account () << "\n";
+							  << "Public: " << genesis.pub.to_string () << "\n"
+							  << "Account: " << genesis.pub.to_account () << "\n";
 					nano::keypair landing;
 					std::cout << "Landing: " << landing.prv.to_string () << "\n"
-					          << "Public: " << landing.pub.to_string () << "\n"
-					          << "Account: " << landing.pub.to_account () << "\n";
+							  << "Public: " << landing.pub.to_string () << "\n"
+							  << "Account: " << landing.pub.to_account () << "\n";
 					for (auto i (0); i != 32; ++i)
 					{
 						nano::keypair rep;
 						std::cout << "Rep" << i << ": " << rep.prv.to_string () << "\n"
-						          << "Public: " << rep.pub.to_string () << "\n"
-						          << "Account: " << rep.pub.to_account () << "\n";
+								  << "Public: " << rep.pub.to_string () << "\n"
+								  << "Account: " << rep.pub.to_account () << "\n";
 					}
 					nano::network_constants network_constants;
 					nano::uint128_t balance (std::numeric_limits<nano::uint128_t>::max ());
@@ -610,10 +610,10 @@ int main (int argc, char * const * argv)
 							nano::logger_mt logger;
 							nano::opencl_config config (platform, device, threads);
 							auto opencl (nano::opencl_work::create (true, config, logger));
-							nano::work_pool work_pool (0, std::chrono::nanoseconds (0), opencl ? [&opencl](nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> &) {
+							nano::work_pool work_pool (0, std::chrono::nanoseconds (0), opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> &) {
 								return opencl->generate_work (version_a, root_a, difficulty_a);
 							}
-							                                                                   : std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> (nullptr));
+																							   : std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> (nullptr));
 							nano::change_block block (0, 0, nano::keypair ().prv, 0, 0);
 							std::cerr << boost::str (boost::format ("Starting OpenCL generation profiling. Platform: %1%. Device: %2%. Threads: %3%. Difficulty: %4$#x (%5%x from base difficulty %6$#x)\n") % platform % device % threads % difficulty % nano::to_string (nano::difficulty::to_multiplier (difficulty, network_constants.publish_full.base), 4) % network_constants.publish_full.base);
 							for (uint64_t i (0); true; ++i)
@@ -628,14 +628,14 @@ int main (int argc, char * const * argv)
 						else
 						{
 							std::cout << "Not available device id\n"
-							          << std::endl;
+									  << std::endl;
 							result = -1;
 						}
 					}
 					else
 					{
 						std::cout << "Not available platform id\n"
-						          << std::endl;
+								  << std::endl;
 						result = -1;
 					}
 				}
@@ -655,7 +655,7 @@ int main (int argc, char * const * argv)
 
 				boost::stacktrace::stacktrace st = boost::stacktrace::stacktrace::from_dump (ifs);
 				std::cout << "Latest crash backtrace:\n"
-				          << st << std::endl;
+						  << st << std::endl;
 			}
 		}
 		else if (vm.count ("debug_generate_crash_report"))
@@ -782,7 +782,7 @@ int main (int argc, char * const * argv)
 					// and inform the user that it needs installing
 					std::vector<int> system_codes;
 
-					auto run_addr2line = [&backtrace_addresses, &base_addresses, &system_codes, &crash_report_filename](bool use_relative_addresses) {
+					auto run_addr2line = [&backtrace_addresses, &base_addresses, &system_codes, &crash_report_filename] (bool use_relative_addresses) {
 						for (auto backtrace_address : backtrace_addresses)
 						{
 							// Find the closest address to it
@@ -809,7 +809,7 @@ int main (int argc, char * const * argv)
 					{
 						std::ofstream ofs (crash_report_filename, std::ios_base::out | std::ios_base::app);
 						ofs << std::endl
-						    << "Using relative addresses:" << std::endl; // Add an empty line to separate the absolute & relative output
+							<< "Using relative addresses:" << std::endl; // Add an empty line to separate the absolute & relative output
 					}
 
 					// Now run using relative addresses. This will give actual results for other dlls, the results from the nano_node executable.
@@ -912,27 +912,27 @@ int main (int argc, char * const * argv)
 				genesis_balance = genesis_balance - 1000000000;
 
 				auto send = builder.state ()
-				            .account (dev_params.ledger.dev_genesis_key.pub)
-				            .previous (genesis_latest)
-				            .representative (dev_params.ledger.dev_genesis_key.pub)
-				            .balance (genesis_balance)
-				            .link (keys[i].pub)
-				            .sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
-				            .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1))
-				            .build ();
+							.account (dev_params.ledger.dev_genesis_key.pub)
+							.previous (genesis_latest)
+							.representative (dev_params.ledger.dev_genesis_key.pub)
+							.balance (genesis_balance)
+							.link (keys[i].pub)
+							.sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
+							.work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1))
+							.build ();
 
 				genesis_latest = send->hash ();
 				blocks.push_back (std::move (send));
 
 				auto open = builder.state ()
-				            .account (keys[i].pub)
-				            .previous (0)
-				            .representative (keys[i].pub)
-				            .balance (balances[i])
-				            .link (genesis_latest)
-				            .sign (keys[i].prv, keys[i].pub)
-				            .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.network.publish_thresholds.epoch_1))
-				            .build ();
+							.account (keys[i].pub)
+							.previous (0)
+							.representative (keys[i].pub)
+							.balance (balances[i])
+							.link (genesis_latest)
+							.sign (keys[i].prv, keys[i].pub)
+							.work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.network.publish_thresholds.epoch_1))
+							.build ();
 
 				frontiers[i] = open->hash ();
 				blocks.push_back (std::move (open));
@@ -946,14 +946,14 @@ int main (int argc, char * const * argv)
 					--balances[j];
 
 					auto send = builder.state ()
-					            .account (keys[j].pub)
-					            .previous (frontiers[j].as_block_hash ())
-					            .representative (keys[j].pub)
-					            .balance (balances[j])
-					            .link (keys[other].pub)
-					            .sign (keys[j].prv, keys[j].pub)
-					            .work (*node->work.generate (nano::work_version::work_1, frontiers[j], node->network_params.network.publish_thresholds.epoch_1))
-					            .build ();
+								.account (keys[j].pub)
+								.previous (frontiers[j].as_block_hash ())
+								.representative (keys[j].pub)
+								.balance (balances[j])
+								.link (keys[other].pub)
+								.sign (keys[j].prv, keys[j].pub)
+								.work (*node->work.generate (nano::work_version::work_1, frontiers[j], node->network_params.network.publish_thresholds.epoch_1))
+								.build ();
 
 					frontiers[j] = send->hash ();
 					blocks.push_back (std::move (send));
@@ -961,14 +961,14 @@ int main (int argc, char * const * argv)
 					++balances[other];
 
 					auto receive = builder.state ()
-					               .account (keys[other].pub)
-					               .previous (frontiers[other].as_block_hash ())
-					               .representative (keys[other].pub)
-					               .balance (balances[other])
-					               .link (frontiers[j].as_block_hash ())
-					               .sign (keys[other].prv, keys[other].pub)
-					               .work (*node->work.generate (nano::work_version::work_1, frontiers[other], node->network_params.network.publish_thresholds.epoch_1))
-					               .build ();
+								   .account (keys[other].pub)
+								   .previous (frontiers[other].as_block_hash ())
+								   .representative (keys[other].pub)
+								   .balance (balances[other])
+								   .link (frontiers[j].as_block_hash ())
+								   .sign (keys[other].prv, keys[other].pub)
+								   .work (*node->work.generate (nano::work_version::work_1, frontiers[other], node->network_params.network.publish_thresholds.epoch_1))
+								   .build ();
 
 					frontiers[other] = receive->hash ();
 					blocks.push_back (std::move (receive));
@@ -1027,27 +1027,27 @@ int main (int argc, char * const * argv)
 				genesis_balance = genesis_balance - balance;
 
 				auto send = builder.state ()
-				            .account (dev_params.ledger.dev_genesis_key.pub)
-				            .previous (genesis_latest)
-				            .representative (dev_params.ledger.dev_genesis_key.pub)
-				            .balance (genesis_balance)
-				            .link (keys[i].pub)
-				            .sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
-				            .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1))
-				            .build ();
+							.account (dev_params.ledger.dev_genesis_key.pub)
+							.previous (genesis_latest)
+							.representative (dev_params.ledger.dev_genesis_key.pub)
+							.balance (genesis_balance)
+							.link (keys[i].pub)
+							.sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
+							.work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1))
+							.build ();
 
 				genesis_latest = send->hash ();
 				node->ledger.process (transaction, *send);
 
 				auto open = builder.state ()
-				            .account (keys[i].pub)
-				            .previous (0)
-				            .representative (keys[i].pub)
-				            .balance (balance)
-				            .link (genesis_latest)
-				            .sign (keys[i].prv, keys[i].pub)
-				            .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.network.publish_thresholds.epoch_1))
-				            .build ();
+							.account (keys[i].pub)
+							.previous (0)
+							.representative (keys[i].pub)
+							.balance (balance)
+							.link (genesis_latest)
+							.sign (keys[i].prv, keys[i].pub)
+							.work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.network.publish_thresholds.epoch_1))
+							.build ();
 
 				node->ledger.process (transaction, *open);
 			}
@@ -1059,14 +1059,14 @@ int main (int argc, char * const * argv)
 				nano::keypair destination;
 
 				auto send = builder.state ()
-				            .account (dev_params.ledger.dev_genesis_key.pub)
-				            .previous (genesis_latest)
-				            .representative (dev_params.ledger.dev_genesis_key.pub)
-				            .balance (genesis_balance)
-				            .link (destination.pub)
-				            .sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
-				            .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1))
-				            .build ();
+							.account (dev_params.ledger.dev_genesis_key.pub)
+							.previous (genesis_latest)
+							.representative (dev_params.ledger.dev_genesis_key.pub)
+							.balance (genesis_balance)
+							.link (destination.pub)
+							.sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
+							.work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1))
+							.build ();
 
 				genesis_latest = send->hash ();
 				blocks.push_back (std::move (send));
@@ -1166,26 +1166,26 @@ int main (int argc, char * const * argv)
 				genesis_balance = genesis_balance - 1;
 
 				auto send = builder.state ()
-				            .account (dev_params.ledger.dev_genesis_key.pub)
-				            .previous (genesis_latest)
-				            .representative (dev_params.ledger.dev_genesis_key.pub)
-				            .balance (genesis_balance)
-				            .link (key.pub)
-				            .sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
-				            .work (*work.generate (nano::work_version::work_1, genesis_latest, dev_params.network.publish_thresholds.epoch_1))
-				            .build ();
+							.account (dev_params.ledger.dev_genesis_key.pub)
+							.previous (genesis_latest)
+							.representative (dev_params.ledger.dev_genesis_key.pub)
+							.balance (genesis_balance)
+							.link (key.pub)
+							.sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
+							.work (*work.generate (nano::work_version::work_1, genesis_latest, dev_params.network.publish_thresholds.epoch_1))
+							.build ();
 
 				genesis_latest = send->hash ();
 
 				auto open = builder.state ()
-				            .account (key.pub)
-				            .previous (0)
-				            .representative (key.pub)
-				            .balance (1)
-				            .link (genesis_latest)
-				            .sign (key.prv, key.pub)
-				            .work (*work.generate (nano::work_version::work_1, key.pub, dev_params.network.publish_thresholds.epoch_1))
-				            .build ();
+							.account (key.pub)
+							.previous (0)
+							.representative (key.pub)
+							.balance (1)
+							.link (genesis_latest)
+							.sign (key.prv, key.pub)
+							.work (*work.generate (nano::work_version::work_1, key.pub, dev_params.network.publish_thresholds.epoch_1))
+							.build ();
 
 				blocks.push_back (std::move (send));
 				blocks.push_back (std::move (open));
@@ -1232,7 +1232,7 @@ int main (int argc, char * const * argv)
 			if (error)
 			{
 				std::cerr << "\n"
-				          << error.get_message () << std::endl;
+						  << error.get_message () << std::endl;
 				std::exit (1);
 			}
 			else
@@ -1321,7 +1321,7 @@ int main (int argc, char * const * argv)
 				command_l << rpc_input_l;
 			}
 
-			auto response_handler_l ([](std::string const & response_a) {
+			auto response_handler_l ([] (std::string const & response_a) {
 				std::cout << response_a;
 				// Terminate as soon as we have the result, even if background threads (like work generation) are running.
 				std::exit (0);
@@ -1367,7 +1367,7 @@ int main (int argc, char * const * argv)
 			std::atomic<uint64_t> block_count (0);
 			std::atomic<uint64_t> errors (0);
 
-			auto print_error_message = [&silent, &errors](std::string const & error_message_a) {
+			auto print_error_message = [&silent, &errors] (std::string const & error_message_a) {
 				if (!silent)
 				{
 					static nano::mutex cerr_mutex;
@@ -1377,10 +1377,10 @@ int main (int argc, char * const * argv)
 				++errors;
 			};
 
-			auto start_threads = [node, &threads_count, &threads, &mutex, &condition, &finished](const auto & function_a, auto & deque_a) {
+			auto start_threads = [node, &threads_count, &threads, &mutex, &condition, &finished] (const auto & function_a, auto & deque_a) {
 				for (auto i (0U); i < threads_count; ++i)
 				{
-					threads.emplace_back ([&function_a, node, &mutex, &condition, &finished, &deque_a]() {
+					threads.emplace_back ([&function_a, node, &mutex, &condition, &finished, &deque_a] () {
 						auto transaction (node->store.tx_begin_read ());
 						nano::unique_lock<nano::mutex> lock (mutex);
 						while (!deque_a.empty () || !finished)
@@ -1402,7 +1402,7 @@ int main (int argc, char * const * argv)
 				}
 			};
 
-			auto check_account = [&print_error_message, &silent, &count, &block_count](std::shared_ptr<nano::node> const & node, nano::read_transaction const & transaction, nano::account const & account, nano::account_info const & info) {
+			auto check_account = [&print_error_message, &silent, &count, &block_count] (std::shared_ptr<nano::node> const & node, nano::read_transaction const & transaction, nano::account const & account, nano::account_info const & info) {
 				++count;
 				if (!silent && (count % 20000) == 0)
 				{
@@ -1676,7 +1676,7 @@ int main (int argc, char * const * argv)
 			finished = false;
 			std::deque<std::pair<nano::pending_key, nano::pending_info>> pending;
 
-			auto check_pending = [&print_error_message, &silent, &count](std::shared_ptr<nano::node> const & node, nano::read_transaction const & transaction, nano::pending_key const & key, nano::pending_info const & info) {
+			auto check_pending = [&print_error_message, &silent, &count] (std::shared_ptr<nano::node> const & node, nano::read_transaction const & transaction, nano::pending_key const & key, nano::pending_info const & info) {
 				++count;
 				if (!silent && (count % 500000) == 0)
 				{
@@ -1912,7 +1912,7 @@ int main (int argc, char * const * argv)
 			nano::locked<std::vector<boost::unordered_set<nano::account>>> opened_account_versions_shared (epoch_count);
 			using opened_account_versions_t = decltype (opened_account_versions_shared)::value_type;
 			node->store.accounts_for_each_par (
-			[&opened_account_versions_shared, epoch_count](nano::read_transaction const & /*unused*/, nano::store_iterator<nano::account, nano::account_info> i, nano::store_iterator<nano::account, nano::account_info> n) {
+			[&opened_account_versions_shared, epoch_count] (nano::read_transaction const & /*unused*/, nano::store_iterator<nano::account, nano::account_info> i, nano::store_iterator<nano::account, nano::account_info> n) {
 				// First cache locally
 				opened_account_versions_t opened_account_versions_l (epoch_count);
 				for (; i != n; ++i)
@@ -1949,7 +1949,7 @@ int main (int argc, char * const * argv)
 			nano::locked<boost::unordered_map<nano::account, std::underlying_type_t<nano::epoch>>> unopened_highest_pending_shared;
 			using unopened_highest_pending_t = decltype (unopened_highest_pending_shared)::value_type;
 			node->store.pending_for_each_par (
-			[&unopened_highest_pending_shared, &opened_accounts](nano::read_transaction const & /*unused*/, nano::store_iterator<nano::pending_key, nano::pending_info> i, nano::store_iterator<nano::pending_key, nano::pending_info> n) {
+			[&unopened_highest_pending_shared, &opened_accounts] (nano::read_transaction const & /*unused*/, nano::store_iterator<nano::pending_key, nano::pending_info> i, nano::store_iterator<nano::pending_key, nano::pending_info> n) {
 				// First cache locally
 				unopened_highest_pending_t unopened_highest_pending_l;
 				for (; i != n; ++i)
@@ -1975,7 +1975,7 @@ int main (int argc, char * const * argv)
 				}
 			});
 
-			auto output_account_version_number = [](auto version, auto num_accounts) {
+			auto output_account_version_number = [] (auto version, auto num_accounts) {
 				std::cout << "Account version " << version << " num accounts: " << num_accounts << "\n";
 			};
 
@@ -2021,7 +2021,7 @@ int main (int argc, char * const * argv)
 		else if (vm.count ("version"))
 		{
 			std::cout << "Version " << NANO_VERSION_STRING << "\n"
-			          << "Build Info " << BUILD_INFO << std::endl;
+					  << "Build Info " << BUILD_INFO << std::endl;
 		}
 		else
 		{
@@ -2041,7 +2041,7 @@ std::istream & operator>> (std::istream & in, uint64_from_hex & out_val)
 }
 
 address_library_pair::address_library_pair (uint64_t address, std::string library) :
-address (address), library (library)
+	address (address), library (library)
 {
 }
 
diff --git a/nano/nano_rpc/entry.cpp b/nano/nano_rpc/entry.cpp
index f4cff3433a..5597a7196f 100644
--- a/nano/nano_rpc/entry.cpp
+++ b/nano/nano_rpc/entry.cpp
@@ -54,7 +54,7 @@ void run (boost::filesystem::path const & data_path, std::vector<std::string> co
 			rpc->start ();
 
 			debug_assert (!nano::signal_handler_impl);
-			nano::signal_handler_impl = [&io_ctx]() {
+			nano::signal_handler_impl = [&io_ctx] () {
 				io_ctx.stop ();
 				sig_int_or_term = 1;
 			};
@@ -136,7 +136,7 @@ int main (int argc, char * const * argv)
 	else if (vm.count ("version"))
 	{
 		std::cout << "Version " << NANO_VERSION_STRING << "\n"
-		          << "Build Info " << BUILD_INFO << std::endl;
+				  << "Build Info " << BUILD_INFO << std::endl;
 	}
 	else
 	{
diff --git a/nano/nano_wallet/entry.cpp b/nano/nano_wallet/entry.cpp
index 74db6478a3..a5c9de4b29 100644
--- a/nano/nano_wallet/entry.cpp
+++ b/nano/nano_wallet/entry.cpp
@@ -107,10 +107,10 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost
 		std::shared_ptr<nano_qt::wallet> gui;
 		nano::set_application_icon (application);
 		auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger));
-		nano::work_pool work (config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl](nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> &) {
+		nano::work_pool work (config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> &) {
 			return opencl->generate_work (version_a, root_a, difficulty_a);
 		}
-		                                                                                       : std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> (nullptr));
+																							   : std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> (nullptr));
 		node = std::make_shared<nano::node> (io_ctx, data_path, config.node, work, flags);
 		if (!node->init_error ())
 		{
@@ -189,7 +189,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost
 					rpc_process = std::make_unique<boost::process::child> (config.rpc.child_process.rpc_path, "--daemon", "--data_path", data_path, "--network", network);
 				}
 			}
-			QObject::connect (&application, &QApplication::aboutToQuit, [&]() {
+			QObject::connect (&application, &QApplication::aboutToQuit, [&] () {
 				ipc.stop ();
 				node->stop ();
 				if (rpc)
@@ -209,7 +209,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost
 #endif
 				runner.stop_event_processing ();
 			});
-			application.postEvent (&processor, new nano_qt::eventloop_event ([&]() {
+			application.postEvent (&processor, new nano_qt::eventloop_event ([&] () {
 				gui = std::make_shared<nano_qt::wallet> (application, processor, *node, wallet, wallet_config.account);
 				splash->close ();
 				gui->start ();
diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp
index fad07ec289..fbb2ff5126 100644
--- a/nano/node/active_transactions.cpp
+++ b/nano/node/active_transactions.cpp
@@ -19,19 +19,19 @@ size_t constexpr nano::active_transactions::max_active_elections_frontier_insert
 constexpr std::chrono::minutes nano::active_transactions::expired_optimistic_election_info_cutoff;
 
 nano::active_transactions::active_transactions (nano::node & node_a, nano::confirmation_height_processor & confirmation_height_processor_a) :
-scheduler{ node_a.scheduler }, // Move dependencies requiring this circular reference
-confirmation_height_processor{ confirmation_height_processor_a },
-node{ node_a },
-multipliers_cb{ 20, 1. },
-trended_active_multiplier{ 1.0 },
-generator{ node_a.config, node_a.ledger, node_a.wallets, node_a.vote_processor, node_a.history, node_a.network, node_a.stats },
-check_all_elections_period{ node_a.network_params.network.is_dev_network () ? 10ms : 5s },
-election_time_to_live{ node_a.network_params.network.is_dev_network () ? 0s : 2s },
-prioritized_cutoff{ std::max<size_t> (1, node_a.config.active_elections_size / 10) },
-thread ([this] () {
-	nano::thread_role::set (nano::thread_role::name::request_loop);
-	request_loop ();
-})
+	scheduler{ node_a.scheduler }, // Move dependencies requiring this circular reference
+	confirmation_height_processor{ confirmation_height_processor_a },
+	node{ node_a },
+	multipliers_cb{ 20, 1. },
+	trended_active_multiplier{ 1.0 },
+	generator{ node_a.config, node_a.ledger, node_a.wallets, node_a.vote_processor, node_a.history, node_a.network, node_a.stats },
+	check_all_elections_period{ node_a.network_params.network.is_dev_network () ? 10ms : 5s },
+	election_time_to_live{ node_a.network_params.network.is_dev_network () ? 0s : 2s },
+	prioritized_cutoff{ std::max<size_t> (1, node_a.config.active_elections_size / 10) },
+	thread ([this] () {
+		nano::thread_role::set (nano::thread_role::name::request_loop);
+		request_loop ();
+	})
 {
 	// Register a callback which will get called after a block is cemented
 	confirmation_height_processor.add_cemented_observer ([this] (std::shared_ptr<nano::block> const & callback_block_a) {
@@ -1453,7 +1453,7 @@ nano::inactive_cache_status nano::active_transactions::inactive_votes_bootstrap_
 {
 	debug_assert (!lock_a.owns_lock ());
 	nano::inactive_cache_status status (previously_a);
-	constexpr unsigned election_start_voters_min{ 5 };
+	const unsigned election_start_voters_min = node.network_params.network.is_dev_network () ? 2 : node.network_params.network.is_beta_network () ? 5 : 15;
 	status.tally = tally_a;
 	if (!previously_a.confirmed && tally_a >= node.online_reps.delta ())
 	{
@@ -1475,11 +1475,8 @@ nano::inactive_cache_status nano::active_transactions::inactive_votes_bootstrap_
 		auto block = node.store.block_get (transaction, hash_a);
 		if (block && status.election_started && !previously_a.election_started && !node.block_confirmed_or_being_confirmed (transaction, hash_a))
 		{
-			if (node.ledger.cache.cemented_count >= node.ledger.bootstrap_weight_max_blocks)
-			{
-				lock_a.lock ();
-				insert_impl (lock_a, block);
-			}
+			lock_a.lock ();
+			insert_impl (lock_a, block);
 		}
 		else if (!block && status.bootstrap_started && !previously_a.bootstrap_started && (!node.ledger.pruning || !node.store.pruned_exists (transaction, hash_a)))
 		{
@@ -1507,13 +1504,13 @@ size_t nano::active_transactions::election_winner_details_size ()
 }
 
 nano::cementable_account::cementable_account (nano::account const & account_a, size_t blocks_uncemented_a) :
-account (account_a), blocks_uncemented (blocks_uncemented_a)
+	account (account_a), blocks_uncemented (blocks_uncemented_a)
 {
 }
 
 nano::expired_optimistic_election_info::expired_optimistic_election_info (std::chrono::steady_clock::time_point expired_time_a, nano::account account_a) :
-expired_time (expired_time_a),
-account (account_a)
+	expired_time (expired_time_a),
+	account (account_a)
 {
 }
 
diff --git a/nano/node/active_transactions.hpp b/nano/node/active_transactions.hpp
index ca3b89b0a3..de96d7ca8e 100644
--- a/nano/node/active_transactions.hpp
+++ b/nano/node/active_transactions.hpp
@@ -69,9 +69,9 @@ class inactive_cache_information final
 public:
 	inactive_cache_information () = default;
 	inactive_cache_information (std::chrono::steady_clock::time_point arrival, nano::block_hash hash, nano::account initial_rep_a, uint64_t initial_timestamp_a, nano::inactive_cache_status status) :
-	arrival (arrival),
-	hash (hash),
-	status (status)
+		arrival (arrival),
+		hash (hash),
+		status (status)
 	{
 		voters.reserve (8);
 		voters.emplace_back (initial_rep_a, initial_timestamp_a);
diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp
index 4718d933a7..2134b4ad7a 100644
--- a/nano/node/blockprocessor.cpp
+++ b/nano/node/blockprocessor.cpp
@@ -11,7 +11,7 @@
 std::chrono::milliseconds constexpr nano::block_processor::confirmation_request_delay;
 
 nano::block_post_events::block_post_events (std::function<nano::read_transaction ()> && get_transaction_a) :
-get_transaction (std::move (get_transaction_a))
+	get_transaction (std::move (get_transaction_a))
 {
 }
 
@@ -26,10 +26,10 @@ nano::block_post_events::~block_post_events ()
 }
 
 nano::block_processor::block_processor (nano::node & node_a, nano::write_database_queue & write_database_queue_a) :
-next_log (std::chrono::steady_clock::now ()),
-node (node_a),
-write_database_queue (write_database_queue_a),
-state_block_signature_verification (node.checker, node.ledger.network_params.ledger.epochs, node.config, node.logger, node.flags.block_processor_verification_size)
+	next_log (std::chrono::steady_clock::now ()),
+	node (node_a),
+	write_database_queue (write_database_queue_a),
+	state_block_signature_verification (node.checker, node.ledger.network_params.ledger.epochs, node.config, node.logger, node.flags.block_processor_verification_size)
 {
 	state_block_signature_verification.blocks_verified_callback = [this] (std::deque<std::pair<nano::unchecked_info, bool>> & items, std::vector<int> const & verifications, std::vector<nano::block_hash> const & hashes, std::vector<nano::signature> const & blocks_signatures) {
 		this->process_verified_state_blocks (items, verifications, hashes, blocks_signatures);
diff --git a/nano/node/bootstrap/bootstrap.cpp b/nano/node/bootstrap/bootstrap.cpp
index 96776d9c86..d3d0bf4526 100644
--- a/nano/node/bootstrap/bootstrap.cpp
+++ b/nano/node/bootstrap/bootstrap.cpp
@@ -10,16 +10,16 @@
 #include <algorithm>
 
 nano::bootstrap_initiator::bootstrap_initiator (nano::node & node_a) :
-node (node_a)
+	node (node_a)
 {
 	connections = std::make_shared<nano::bootstrap_connections> (node);
-	bootstrap_initiator_threads.push_back (boost::thread ([this]() {
+	bootstrap_initiator_threads.push_back (boost::thread ([this] () {
 		nano::thread_role::set (nano::thread_role::name::bootstrap_connections);
 		connections->run ();
 	}));
 	for (size_t i = 0; i < node.config.bootstrap_initiator_threads; ++i)
 	{
-		bootstrap_initiator_threads.push_back (boost::thread ([this]() {
+		bootstrap_initiator_threads.push_back (boost::thread ([this] () {
 			nano::thread_role::set (nano::thread_role::name::bootstrap_initiator);
 			run_bootstrap ();
 		}));
@@ -157,7 +157,7 @@ void nano::bootstrap_initiator::lazy_requeue (nano::block_hash const & hash_a, n
 	}
 }
 
-void nano::bootstrap_initiator::add_observer (std::function<void(bool)> const & observer_a)
+void nano::bootstrap_initiator::add_observer (std::function<void (bool)> const & observer_a)
 {
 	nano::lock_guard<nano::mutex> lock (observers_mutex);
 	observers.push_back (observer_a);
@@ -327,7 +327,7 @@ void nano::pulls_cache::add (nano::pull_info const & pull_a)
 		else
 		{
 			// Update existing pull
-			cache.get<account_head_tag> ().modify (existing, [pull_a](nano::cached_pulls & cache_a) {
+			cache.get<account_head_tag> ().modify (existing, [pull_a] (nano::cached_pulls & cache_a) {
 				cache_a.time = std::chrono::steady_clock::now ();
 				cache_a.new_head = pull_a.head;
 			});
diff --git a/nano/node/bootstrap/bootstrap.hpp b/nano/node/bootstrap/bootstrap.hpp
index 07f64b63e0..ebb693b812 100644
--- a/nano/node/bootstrap/bootstrap.hpp
+++ b/nano/node/bootstrap/bootstrap.hpp
@@ -88,7 +88,7 @@ class bootstrap_initiator final
 	void run_bootstrap ();
 	void lazy_requeue (nano::block_hash const &, nano::block_hash const &, bool);
 	void notify_listeners (bool);
-	void add_observer (std::function<void(bool)> const &);
+	void add_observer (std::function<void (bool)> const &);
 	bool in_progress ();
 	std::shared_ptr<nano::bootstrap_connections> connections;
 	std::shared_ptr<nano::bootstrap_attempt> new_attempt ();
@@ -110,7 +110,7 @@ class bootstrap_initiator final
 	nano::mutex mutex;
 	nano::condition_variable condition;
 	nano::mutex observers_mutex;
-	std::vector<std::function<void(bool)>> observers;
+	std::vector<std::function<void (bool)>> observers;
 	std::vector<boost::thread> bootstrap_initiator_threads;
 
 	friend std::unique_ptr<container_info_component> collect_container_info (bootstrap_initiator & bootstrap_initiator, std::string const & name);
diff --git a/nano/node/bootstrap/bootstrap_attempt.cpp b/nano/node/bootstrap/bootstrap_attempt.cpp
index 8d318501f0..858891742b 100644
--- a/nano/node/bootstrap/bootstrap_attempt.cpp
+++ b/nano/node/bootstrap/bootstrap_attempt.cpp
@@ -16,10 +16,10 @@ constexpr unsigned nano::bootstrap_limits::requeued_pulls_limit;
 constexpr unsigned nano::bootstrap_limits::requeued_pulls_limit_dev;
 
 nano::bootstrap_attempt::bootstrap_attempt (std::shared_ptr<nano::node> const & node_a, nano::bootstrap_mode mode_a, uint64_t incremental_id_a, std::string id_a) :
-node (node_a),
-incremental_id (incremental_id_a),
-id (id_a),
-mode (mode_a)
+	node (node_a),
+	incremental_id (incremental_id_a),
+	id (id_a),
+	mode (mode_a)
 {
 	if (id.empty ())
 	{
diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp
index be759448e2..3894317782 100644
--- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp
+++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp
@@ -8,23 +8,23 @@
 #include <boost/format.hpp>
 
 nano::pull_info::pull_info (nano::hash_or_account const & account_or_head_a, nano::block_hash const & head_a, nano::block_hash const & end_a, uint64_t bootstrap_id_a, count_t count_a, unsigned retry_limit_a) :
-account_or_head (account_or_head_a),
-head (head_a),
-head_original (head_a),
-end (end_a),
-count (count_a),
-retry_limit (retry_limit_a),
-bootstrap_id (bootstrap_id_a)
+	account_or_head (account_or_head_a),
+	head (head_a),
+	head_original (head_a),
+	end (end_a),
+	count (count_a),
+	retry_limit (retry_limit_a),
+	bootstrap_id (bootstrap_id_a)
 {
 }
 
 nano::bulk_pull_client::bulk_pull_client (std::shared_ptr<nano::bootstrap_client> const & connection_a, std::shared_ptr<nano::bootstrap_attempt> const & attempt_a, nano::pull_info const & pull_a) :
-connection (connection_a),
-attempt (attempt_a),
-known_account (0),
-pull (pull_a),
-pull_blocks (0),
-unexpected_count (0)
+	connection (connection_a),
+	attempt (attempt_a),
+	known_account (0),
+	pull (pull_a),
+	pull_blocks (0),
+	unexpected_count (0)
 {
 	attempt->condition.notify_all ();
 }
@@ -83,7 +83,7 @@ void nano::bulk_pull_client::request ()
 	}
 	auto this_l (shared_from_this ());
 	connection->channel->send (
-	req, [this_l](boost::system::error_code const & ec, size_t size_a) {
+	req, [this_l] (boost::system::error_code const & ec, size_t size_a) {
 		if (!ec)
 		{
 			this_l->throttled_receive_block ();
@@ -110,7 +110,7 @@ void nano::bulk_pull_client::throttled_receive_block ()
 	else
 	{
 		auto this_l (shared_from_this ());
-		connection->node->workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this_l]() {
+		connection->node->workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this_l] () {
 			if (!this_l->connection->pending_stop && !this_l->attempt->stopped)
 			{
 				this_l->throttled_receive_block ();
@@ -122,7 +122,7 @@ void nano::bulk_pull_client::throttled_receive_block ()
 void nano::bulk_pull_client::receive_block ()
 {
 	auto this_l (shared_from_this ());
-	connection->socket->async_read (connection->receive_buffer, 1, [this_l](boost::system::error_code const & ec, size_t size_a) {
+	connection->socket->async_read (connection->receive_buffer, 1, [this_l] (boost::system::error_code const & ec, size_t size_a) {
 		if (!ec)
 		{
 			this_l->received_type ();
@@ -149,35 +149,35 @@ void nano::bulk_pull_client::received_type ()
 	{
 		case nano::block_type::send:
 		{
-			socket_l->async_read (connection->receive_buffer, nano::send_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) {
+			socket_l->async_read (connection->receive_buffer, nano::send_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
 				this_l->received_block (ec, size_a, type);
 			});
 			break;
 		}
 		case nano::block_type::receive:
 		{
-			socket_l->async_read (connection->receive_buffer, nano::receive_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) {
+			socket_l->async_read (connection->receive_buffer, nano::receive_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
 				this_l->received_block (ec, size_a, type);
 			});
 			break;
 		}
 		case nano::block_type::open:
 		{
-			socket_l->async_read (connection->receive_buffer, nano::open_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) {
+			socket_l->async_read (connection->receive_buffer, nano::open_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
 				this_l->received_block (ec, size_a, type);
 			});
 			break;
 		}
 		case nano::block_type::change:
 		{
-			socket_l->async_read (connection->receive_buffer, nano::change_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) {
+			socket_l->async_read (connection->receive_buffer, nano::change_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
 				this_l->received_block (ec, size_a, type);
 			});
 			break;
 		}
 		case nano::block_type::state:
 		{
-			socket_l->async_read (connection->receive_buffer, nano::state_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) {
+			socket_l->async_read (connection->receive_buffer, nano::state_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
 				this_l->received_block (ec, size_a, type);
 			});
 			break;
@@ -285,10 +285,10 @@ void nano::bulk_pull_client::received_block (boost::system::error_code const & e
 }
 
 nano::bulk_pull_account_client::bulk_pull_account_client (std::shared_ptr<nano::bootstrap_client> const & connection_a, std::shared_ptr<nano::bootstrap_attempt> const & attempt_a, nano::account const & account_a) :
-connection (connection_a),
-attempt (attempt_a),
-account (account_a),
-pull_blocks (0)
+	connection (connection_a),
+	attempt (attempt_a),
+	account (account_a),
+	pull_blocks (0)
 {
 	attempt->condition.notify_all ();
 }
@@ -314,7 +314,7 @@ void nano::bulk_pull_account_client::request ()
 	}
 	auto this_l (shared_from_this ());
 	connection->channel->send (
-	req, [this_l](boost::system::error_code const & ec, size_t size_a) {
+	req, [this_l] (boost::system::error_code const & ec, size_t size_a) {
 		if (!ec)
 		{
 			this_l->receive_pending ();
@@ -336,7 +336,7 @@ void nano::bulk_pull_account_client::receive_pending ()
 {
 	auto this_l (shared_from_this ());
 	size_t size_l (sizeof (nano::uint256_union) + sizeof (nano::uint128_union));
-	connection->socket->async_read (connection->receive_buffer, size_l, [this_l, size_l](boost::system::error_code const & ec, size_t size_a) {
+	connection->socket->async_read (connection->receive_buffer, size_l, [this_l, size_l] (boost::system::error_code const & ec, size_t size_a) {
 		// An issue with asio is that sometimes, instead of reporting a bad file descriptor during disconnect,
 		// we simply get a size of 0.
 		if (size_a == size_l)
@@ -494,7 +494,7 @@ void nano::bulk_pull_server::send_next ()
 		{
 			connection->node->logger.try_log (boost::str (boost::format ("Sending block: %1%") % block->hash ().to_string ()));
 		}
-		connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l](boost::system::error_code const & ec, size_t size_a) {
+		connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) {
 			this_l->sent_action (ec, size_a);
 		});
 	}
@@ -598,7 +598,7 @@ void nano::bulk_pull_server::send_finished ()
 	{
 		connection->node->logger.try_log ("Bulk sending finished");
 	}
-	connection->socket->async_write (send_buffer, [this_l](boost::system::error_code const & ec, size_t size_a) {
+	connection->socket->async_write (send_buffer, [this_l] (boost::system::error_code const & ec, size_t size_a) {
 		this_l->no_block_sent (ec, size_a);
 	});
 }
@@ -620,8 +620,8 @@ void nano::bulk_pull_server::no_block_sent (boost::system::error_code const & ec
 }
 
 nano::bulk_pull_server::bulk_pull_server (std::shared_ptr<nano::bootstrap_server> const & connection_a, std::unique_ptr<nano::bulk_pull> request_a) :
-connection (connection_a),
-request (std::move (request_a))
+	connection (connection_a),
+	request (std::move (request_a))
 {
 	set_current_end ();
 }
@@ -700,7 +700,7 @@ void nano::bulk_pull_account_server::send_frontier ()
 
 		// Send the buffer to the requestor
 		auto this_l (shared_from_this ());
-		connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l](boost::system::error_code const & ec, size_t size_a) {
+		connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) {
 			this_l->sent_action (ec, size_a);
 		});
 	}
@@ -756,7 +756,7 @@ void nano::bulk_pull_account_server::send_next_block ()
 		}
 
 		auto this_l (shared_from_this ());
-		connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l](boost::system::error_code const & ec, size_t size_a) {
+		connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) {
 			this_l->sent_action (ec, size_a);
 		});
 	}
@@ -903,7 +903,7 @@ void nano::bulk_pull_account_server::send_finished ()
 		connection->node->logger.try_log ("Bulk sending for an account finished");
 	}
 
-	connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l](boost::system::error_code const & ec, size_t size_a) {
+	connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) {
 		this_l->complete (ec, size_a);
 	});
 }
@@ -940,9 +940,9 @@ void nano::bulk_pull_account_server::complete (boost::system::error_code const &
 }
 
 nano::bulk_pull_account_server::bulk_pull_account_server (std::shared_ptr<nano::bootstrap_server> const & connection_a, std::unique_ptr<nano::bulk_pull_account> request_a) :
-connection (connection_a),
-request (std::move (request_a)),
-current_key (0, 0)
+	connection (connection_a),
+	request (std::move (request_a)),
+	current_key (0, 0)
 {
 	/*
 	 * Setup the streaming response for the first call to "send_frontier" and  "send_next_block"
diff --git a/nano/node/bootstrap/bootstrap_bulk_push.cpp b/nano/node/bootstrap/bootstrap_bulk_push.cpp
index 06c7dc0d98..1be43031d3 100644
--- a/nano/node/bootstrap/bootstrap_bulk_push.cpp
+++ b/nano/node/bootstrap/bootstrap_bulk_push.cpp
@@ -6,8 +6,8 @@
 #include <boost/format.hpp>
 
 nano::bulk_push_client::bulk_push_client (std::shared_ptr<nano::bootstrap_client> const & connection_a, std::shared_ptr<nano::bootstrap_attempt> const & attempt_a) :
-connection (connection_a),
-attempt (attempt_a)
+	connection (connection_a),
+	attempt (attempt_a)
 {
 }
 
@@ -20,7 +20,7 @@ void nano::bulk_push_client::start ()
 	nano::bulk_push message;
 	auto this_l (shared_from_this ());
 	connection->channel->send (
-	message, [this_l](boost::system::error_code const & ec, size_t size_a) {
+	message, [this_l] (boost::system::error_code const & ec, size_t size_a) {
 		if (!ec)
 		{
 			this_l->push ();
@@ -77,7 +77,7 @@ void nano::bulk_push_client::send_finished ()
 {
 	nano::shared_const_buffer buffer (static_cast<uint8_t> (nano::block_type::not_a_block));
 	auto this_l (shared_from_this ());
-	connection->channel->send_buffer (buffer, [this_l](boost::system::error_code const & ec, size_t size_a) {
+	connection->channel->send_buffer (buffer, [this_l] (boost::system::error_code const & ec, size_t size_a) {
 		try
 		{
 			this_l->promise.set_value (false);
@@ -96,7 +96,7 @@ void nano::bulk_push_client::push_block (nano::block const & block_a)
 		nano::serialize_block (stream, block_a);
 	}
 	auto this_l (shared_from_this ());
-	connection->channel->send_buffer (nano::shared_const_buffer (std::move (buffer)), [this_l](boost::system::error_code const & ec, size_t size_a) {
+	connection->channel->send_buffer (nano::shared_const_buffer (std::move (buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) {
 		if (!ec)
 		{
 			this_l->push ();
@@ -112,8 +112,8 @@ void nano::bulk_push_client::push_block (nano::block const & block_a)
 }
 
 nano::bulk_push_server::bulk_push_server (std::shared_ptr<nano::bootstrap_server> const & connection_a) :
-receive_buffer (std::make_shared<std::vector<uint8_t>> ()),
-connection (connection_a)
+	receive_buffer (std::make_shared<std::vector<uint8_t>> ()),
+	connection (connection_a)
 {
 	receive_buffer->resize (256);
 }
@@ -127,7 +127,7 @@ void nano::bulk_push_server::throttled_receive ()
 	else
 	{
 		auto this_l (shared_from_this ());
-		connection->node->workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this_l]() {
+		connection->node->workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this_l] () {
 			if (!this_l->connection->stopped)
 			{
 				this_l->throttled_receive ();
@@ -148,7 +148,7 @@ void nano::bulk_push_server::receive ()
 	else
 	{
 		auto this_l (shared_from_this ());
-		connection->socket->async_read (receive_buffer, 1, [this_l](boost::system::error_code const & ec, size_t size_a) {
+		connection->socket->async_read (receive_buffer, 1, [this_l] (boost::system::error_code const & ec, size_t size_a) {
 			if (!ec)
 			{
 				this_l->received_type ();
@@ -173,7 +173,7 @@ void nano::bulk_push_server::received_type ()
 		case nano::block_type::send:
 		{
 			connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::send, nano::stat::dir::in);
-			connection->socket->async_read (receive_buffer, nano::send_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) {
+			connection->socket->async_read (receive_buffer, nano::send_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
 				this_l->received_block (ec, size_a, type);
 			});
 			break;
@@ -181,7 +181,7 @@ void nano::bulk_push_server::received_type ()
 		case nano::block_type::receive:
 		{
 			connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::receive, nano::stat::dir::in);
-			connection->socket->async_read (receive_buffer, nano::receive_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) {
+			connection->socket->async_read (receive_buffer, nano::receive_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
 				this_l->received_block (ec, size_a, type);
 			});
 			break;
@@ -189,7 +189,7 @@ void nano::bulk_push_server::received_type ()
 		case nano::block_type::open:
 		{
 			connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::open, nano::stat::dir::in);
-			connection->socket->async_read (receive_buffer, nano::open_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) {
+			connection->socket->async_read (receive_buffer, nano::open_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
 				this_l->received_block (ec, size_a, type);
 			});
 			break;
@@ -197,7 +197,7 @@ void nano::bulk_push_server::received_type ()
 		case nano::block_type::change:
 		{
 			connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::change, nano::stat::dir::in);
-			connection->socket->async_read (receive_buffer, nano::change_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) {
+			connection->socket->async_read (receive_buffer, nano::change_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
 				this_l->received_block (ec, size_a, type);
 			});
 			break;
@@ -205,7 +205,7 @@ void nano::bulk_push_server::received_type ()
 		case nano::block_type::state:
 		{
 			connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::state_block, nano::stat::dir::in);
-			connection->socket->async_read (receive_buffer, nano::state_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) {
+			connection->socket->async_read (receive_buffer, nano::state_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) {
 				this_l->received_block (ec, size_a, type);
 			});
 			break;
diff --git a/nano/node/bootstrap/bootstrap_connections.cpp b/nano/node/bootstrap/bootstrap_connections.cpp
index 7a1faa87ca..aa5a8a94f7 100644
--- a/nano/node/bootstrap/bootstrap_connections.cpp
+++ b/nano/node/bootstrap/bootstrap_connections.cpp
@@ -14,12 +14,12 @@ constexpr unsigned nano::bootstrap_limits::bootstrap_max_new_connections;
 constexpr unsigned nano::bootstrap_limits::requeued_pulls_processed_blocks_factor;
 
 nano::bootstrap_client::bootstrap_client (std::shared_ptr<nano::node> const & node_a, std::shared_ptr<nano::bootstrap_connections> const & connections_a, std::shared_ptr<nano::transport::channel_tcp> const & channel_a, std::shared_ptr<nano::socket> const & socket_a) :
-node (node_a),
-connections (connections_a),
-channel (channel_a),
-socket (socket_a),
-receive_buffer (std::make_shared<std::vector<uint8_t>> ()),
-start_time_m (std::chrono::steady_clock::now ())
+	node (node_a),
+	connections (connections_a),
+	channel (channel_a),
+	socket (socket_a),
+	receive_buffer (std::make_shared<std::vector<uint8_t>> ()),
+	start_time_m (std::chrono::steady_clock::now ())
 {
 	++connections->connections_count;
 	receive_buffer->resize (256);
@@ -60,14 +60,14 @@ void nano::bootstrap_client::stop (bool force)
 }
 
 nano::bootstrap_connections::bootstrap_connections (nano::node & node_a) :
-node (node_a)
+	node (node_a)
 {
 }
 
 std::shared_ptr<nano::bootstrap_client> nano::bootstrap_connections::connection (std::shared_ptr<nano::bootstrap_attempt> const & attempt_a, bool use_front_connection)
 {
 	nano::unique_lock<nano::mutex> lock (mutex);
-	condition.wait (lock, [& stopped = stopped, &idle = idle, &new_connections_empty = new_connections_empty] { return stopped || !idle.empty () || new_connections_empty; });
+	condition.wait (lock, [&stopped = stopped, &idle = idle, &new_connections_empty = new_connections_empty] { return stopped || !idle.empty () || new_connections_empty; });
 	std::shared_ptr<nano::bootstrap_client> result;
 	if (!stopped && !idle.empty ())
 	{
@@ -147,7 +147,7 @@ void nano::bootstrap_connections::connect_client (nano::tcp_endpoint const & end
 	auto socket (std::make_shared<nano::socket> (node));
 	auto this_l (shared_from_this ());
 	socket->async_connect (endpoint_a,
-	[this_l, socket, endpoint_a, push_front](boost::system::error_code const & ec) {
+	[this_l, socket, endpoint_a, push_front] (boost::system::error_code const & ec) {
 		if (!ec)
 		{
 			if (this_l->node.config.logging.bulk_pull_logging ())
@@ -304,7 +304,7 @@ void nano::bootstrap_connections::populate_connections (bool repeat)
 	if (!stopped && repeat)
 	{
 		std::weak_ptr<nano::bootstrap_connections> this_w (shared_from_this ());
-		node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this_w]() {
+		node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this_w] () {
 			if (auto this_l = this_w.lock ())
 			{
 				this_l->populate_connections ();
@@ -358,7 +358,7 @@ void nano::bootstrap_connections::request_pull (nano::unique_lock<nano::mutex> &
 		{
 			// The bulk_pull_client destructor attempt to requeue_pull which can cause a deadlock if this is the last reference
 			// Dispatch request in an external thread in case it needs to be destroyed
-			node.background ([connection_l, attempt_l, pull]() {
+			node.background ([connection_l, attempt_l, pull] () {
 				auto client (std::make_shared<nano::bulk_pull_client> (connection_l, attempt_l, pull));
 				client->request ();
 			});
diff --git a/nano/node/bootstrap/bootstrap_frontier.cpp b/nano/node/bootstrap/bootstrap_frontier.cpp
index 9708332cd5..f4dcd56a9e 100644
--- a/nano/node/bootstrap/bootstrap_frontier.cpp
+++ b/nano/node/bootstrap/bootstrap_frontier.cpp
@@ -24,7 +24,7 @@ void nano::frontier_req_client::run (nano::account const & start_account_a, uint
 	next (); // Load accounts from disk
 	auto this_l (shared_from_this ());
 	connection->channel->send (
-	request, [this_l](boost::system::error_code const & ec, size_t size_a) {
+	request, [this_l] (boost::system::error_code const & ec, size_t size_a) {
 		if (!ec)
 		{
 			this_l->receive_frontier ();
@@ -41,17 +41,17 @@ void nano::frontier_req_client::run (nano::account const & start_account_a, uint
 }
 
 nano::frontier_req_client::frontier_req_client (std::shared_ptr<nano::bootstrap_client> const & connection_a, std::shared_ptr<nano::bootstrap_attempt> const & attempt_a) :
-connection (connection_a),
-attempt (attempt_a),
-count (0),
-bulk_push_cost (0)
+	connection (connection_a),
+	attempt (attempt_a),
+	count (0),
+	bulk_push_cost (0)
 {
 }
 
 void nano::frontier_req_client::receive_frontier ()
 {
 	auto this_l (shared_from_this ());
-	connection->socket->async_read (connection->receive_buffer, nano::frontier_req_client::size_frontier, [this_l](boost::system::error_code const & ec, size_t size_a) {
+	connection->socket->async_read (connection->receive_buffer, nano::frontier_req_client::size_frontier, [this_l] (boost::system::error_code const & ec, size_t size_a) {
 		// An issue with asio is that sometimes, instead of reporting a bad file descriptor during disconnect,
 		// we simply get a size of 0.
 		if (size_a == nano::frontier_req_client::size_frontier)
@@ -234,11 +234,11 @@ void nano::frontier_req_client::next ()
 }
 
 nano::frontier_req_server::frontier_req_server (std::shared_ptr<nano::bootstrap_server> const & connection_a, std::unique_ptr<nano::frontier_req> request_a) :
-connection (connection_a),
-current (request_a->start.number () - 1),
-frontier (0),
-request (std::move (request_a)),
-count (0)
+	connection (connection_a),
+	current (request_a->start.number () - 1),
+	frontier (0),
+	request (std::move (request_a)),
+	count (0)
 {
 	next ();
 }
@@ -261,7 +261,7 @@ void nano::frontier_req_server::send_next ()
 			connection->node->logger.try_log (boost::str (boost::format ("Sending frontier for %1% %2%") % current.to_account () % frontier.to_string ()));
 		}
 		next ();
-		connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l](boost::system::error_code const & ec, size_t size_a) {
+		connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) {
 			this_l->sent_action (ec, size_a);
 		});
 	}
@@ -285,7 +285,7 @@ void nano::frontier_req_server::send_finished ()
 	{
 		connection->node->logger.try_log ("Frontier sending finished");
 	}
-	connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l](boost::system::error_code const & ec, size_t size_a) {
+	connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) {
 		this_l->no_block_sent (ec, size_a);
 	});
 }
diff --git a/nano/node/bootstrap/bootstrap_lazy.cpp b/nano/node/bootstrap/bootstrap_lazy.cpp
index e79d146776..84e4a9327a 100644
--- a/nano/node/bootstrap/bootstrap_lazy.cpp
+++ b/nano/node/bootstrap/bootstrap_lazy.cpp
@@ -14,7 +14,7 @@ constexpr double nano::bootstrap_limits::lazy_batch_pull_count_resize_ratio;
 constexpr size_t nano::bootstrap_limits::lazy_blocks_restart_limit;
 
 nano::bootstrap_attempt_lazy::bootstrap_attempt_lazy (std::shared_ptr<nano::node> const & node_a, uint64_t incremental_id_a, std::string const & id_a) :
-nano::bootstrap_attempt (node_a, nano::bootstrap_mode::lazy, incremental_id_a, id_a)
+	nano::bootstrap_attempt (node_a, nano::bootstrap_mode::lazy, incremental_id_a, id_a)
 {
 	node->bootstrap_initiator.notify_listeners (true);
 }
@@ -188,7 +188,7 @@ void nano::bootstrap_attempt_lazy::run ()
 		auto this_l (shared_from_this ());
 		while (still_pulling () && !lazy_has_expired ())
 		{
-			condition.wait (lock, [& stopped = stopped, &pulling = pulling, &lazy_pulls = lazy_pulls, this_l] { return stopped || pulling == 0 || (pulling < nano::bootstrap_limits::bootstrap_connection_scale_target_blocks && !lazy_pulls.empty ()) || this_l->lazy_has_expired (); });
+			condition.wait (lock, [&stopped = stopped, &pulling = pulling, &lazy_pulls = lazy_pulls, this_l] { return stopped || pulling == 0 || (pulling < nano::bootstrap_limits::bootstrap_connection_scale_target_blocks && !lazy_pulls.empty ()) || this_l->lazy_has_expired (); });
 			++iterations;
 			// Flushing lazy pulls
 			lazy_pull_flush (lock);
@@ -462,7 +462,7 @@ void nano::bootstrap_attempt_lazy::get_information (boost::property_tree::ptree
 }
 
 nano::bootstrap_attempt_wallet::bootstrap_attempt_wallet (std::shared_ptr<nano::node> const & node_a, uint64_t incremental_id_a, std::string id_a) :
-nano::bootstrap_attempt (node_a, nano::bootstrap_mode::wallet_lazy, incremental_id_a, id_a)
+	nano::bootstrap_attempt (node_a, nano::bootstrap_mode::wallet_lazy, incremental_id_a, id_a)
 {
 	node->bootstrap_initiator.notify_listeners (true);
 }
@@ -485,7 +485,7 @@ void nano::bootstrap_attempt_wallet::request_pending (nano::unique_lock<nano::mu
 		auto this_l (shared_from_this ());
 		// The bulk_pull_account_client destructor attempt to requeue_pull which can cause a deadlock if this is the last reference
 		// Dispatch request in an external thread in case it needs to be destroyed
-		node->background ([connection_l, this_l, account]() {
+		node->background ([connection_l, this_l, account] () {
 			auto client (std::make_shared<nano::bulk_pull_account_client> (connection_l, this_l, account));
 			client->request ();
 		});
diff --git a/nano/node/bootstrap/bootstrap_legacy.cpp b/nano/node/bootstrap/bootstrap_legacy.cpp
index 2bc82318fd..1d61bb5d55 100644
--- a/nano/node/bootstrap/bootstrap_legacy.cpp
+++ b/nano/node/bootstrap/bootstrap_legacy.cpp
@@ -6,9 +6,9 @@
 #include <boost/format.hpp>
 
 nano::bootstrap_attempt_legacy::bootstrap_attempt_legacy (std::shared_ptr<nano::node> const & node_a, uint64_t const incremental_id_a, std::string const & id_a, uint32_t const frontiers_age_a, nano::account const & start_account_a) :
-nano::bootstrap_attempt (node_a, nano::bootstrap_mode::legacy, incremental_id_a, id_a),
-frontiers_age (frontiers_age_a),
-start_account (start_account_a)
+	nano::bootstrap_attempt (node_a, nano::bootstrap_mode::legacy, incremental_id_a, id_a),
+	frontiers_age (frontiers_age_a),
+	start_account (start_account_a)
 {
 	node->bootstrap_initiator.notify_listeners (true);
 }
diff --git a/nano/node/bootstrap/bootstrap_server.cpp b/nano/node/bootstrap/bootstrap_server.cpp
index 866ee4880b..9e244a69f9 100644
--- a/nano/node/bootstrap/bootstrap_server.cpp
+++ b/nano/node/bootstrap/bootstrap_server.cpp
@@ -8,8 +8,8 @@
 #include <boost/variant/get.hpp>
 
 nano::bootstrap_listener::bootstrap_listener (uint16_t port_a, nano::node & node_a) :
-node (node_a),
-port (port_a)
+	node (node_a),
+	port (port_a)
 {
 }
 
@@ -26,7 +26,7 @@ void nano::bootstrap_listener::start ()
 		throw std::runtime_error (ec.message ());
 	}
 	debug_assert (node.network.endpoint ().port () == listening_socket->listening_port ());
-	listening_socket->on_connection ([this](std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) {
+	listening_socket->on_connection ([this] (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const & ec_a) {
 		bool keep_accepting = true;
 		if (ec_a)
 		{
@@ -104,9 +104,9 @@ std::unique_ptr<nano::container_info_component> nano::collect_container_info (bo
 }
 
 nano::bootstrap_server::bootstrap_server (std::shared_ptr<nano::socket> const & socket_a, std::shared_ptr<nano::node> const & node_a) :
-receive_buffer (std::make_shared<std::vector<uint8_t>> ()),
-socket (socket_a),
-node (node_a)
+	receive_buffer (std::make_shared<std::vector<uint8_t>> ()),
+	socket (socket_a),
+	node (node_a)
 {
 	receive_buffer->resize (1024);
 }
@@ -153,7 +153,7 @@ void nano::bootstrap_server::receive ()
 	// Increase timeout to receive TCP header (idle server socket)
 	socket->set_timeout (node->network_params.node.idle_timeout);
 	auto this_l (shared_from_this ());
-	socket->async_read (receive_buffer, 8, [this_l](boost::system::error_code const & ec, size_t size_a) {
+	socket->async_read (receive_buffer, 8, [this_l] (boost::system::error_code const & ec, size_t size_a) {
 		// Set remote_endpoint
 		if (this_l->remote_endpoint.port () == 0)
 		{
@@ -182,7 +182,7 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co
 				case nano::message_type::bulk_pull:
 				{
 					node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull, nano::stat::dir::in);
-					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) {
+					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
 						this_l->receive_bulk_pull_action (ec, size_a, header);
 					});
 					break;
@@ -190,7 +190,7 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co
 				case nano::message_type::bulk_pull_account:
 				{
 					node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_account, nano::stat::dir::in);
-					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) {
+					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
 						this_l->receive_bulk_pull_account_action (ec, size_a, header);
 					});
 					break;
@@ -198,7 +198,7 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co
 				case nano::message_type::frontier_req:
 				{
 					node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::frontier_req, nano::stat::dir::in);
-					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) {
+					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
 						this_l->receive_frontier_req_action (ec, size_a, header);
 					});
 					break;
@@ -214,35 +214,35 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co
 				}
 				case nano::message_type::keepalive:
 				{
-					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) {
+					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
 						this_l->receive_keepalive_action (ec, size_a, header);
 					});
 					break;
 				}
 				case nano::message_type::publish:
 				{
-					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) {
+					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
 						this_l->receive_publish_action (ec, size_a, header);
 					});
 					break;
 				}
 				case nano::message_type::confirm_ack:
 				{
-					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) {
+					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
 						this_l->receive_confirm_ack_action (ec, size_a, header);
 					});
 					break;
 				}
 				case nano::message_type::confirm_req:
 				{
-					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) {
+					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
 						this_l->receive_confirm_req_action (ec, size_a, header);
 					});
 					break;
 				}
 				case nano::message_type::node_id_handshake:
 				{
-					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) {
+					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
 						this_l->receive_node_id_handshake_action (ec, size_a, header);
 					});
 					break;
@@ -269,7 +269,7 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co
 				}
 				case nano::message_type::telemetry_ack:
 				{
-					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header](boost::system::error_code const & ec, size_t size_a) {
+					socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) {
 						this_l->receive_telemetry_ack_action (ec, size_a, header);
 					});
 					break;
@@ -567,7 +567,7 @@ void nano::bootstrap_server::finish_request ()
 	else
 	{
 		std::weak_ptr<nano::bootstrap_server> this_w (shared_from_this ());
-		node->workers.add_timed_task (std::chrono::steady_clock::now () + (node->config.tcp_io_timeout * 2) + std::chrono::seconds (1), [this_w]() {
+		node->workers.add_timed_task (std::chrono::steady_clock::now () + (node->config.tcp_io_timeout * 2) + std::chrono::seconds (1), [this_w] () {
 			if (auto this_l = this_w.lock ())
 			{
 				this_l->timeout ();
@@ -579,7 +579,7 @@ void nano::bootstrap_server::finish_request ()
 void nano::bootstrap_server::finish_request_async ()
 {
 	std::weak_ptr<nano::bootstrap_server> this_w (shared_from_this ());
-	node->background ([this_w]() {
+	node->background ([this_w] () {
 		if (auto this_l = this_w.lock ())
 		{
 			this_l->finish_request ();
@@ -617,7 +617,7 @@ class request_response_visitor : public nano::message_visitor
 {
 public:
 	explicit request_response_visitor (std::shared_ptr<nano::bootstrap_server> const & connection_a) :
-	connection (connection_a)
+		connection (connection_a)
 	{
 	}
 	void keepalive (nano::keepalive const & message_a) override
@@ -677,7 +677,7 @@ class request_response_visitor : public nano::message_visitor
 			auto cookie (connection->node->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (connection->remote_endpoint)));
 			nano::node_id_handshake response_message (cookie, response);
 			auto shared_const_buffer = response_message.to_shared_const_buffer ();
-			connection->socket->async_write (shared_const_buffer, [connection = std::weak_ptr<nano::bootstrap_server> (connection)](boost::system::error_code const & ec, size_t size_a) {
+			connection->socket->async_write (shared_const_buffer, [connection = std::weak_ptr<nano::bootstrap_server> (connection)] (boost::system::error_code const & ec, size_t size_a) {
 				if (auto connection_l = connection.lock ())
 				{
 					if (ec)
@@ -748,7 +748,7 @@ void nano::bootstrap_server::run_next (nano::unique_lock<nano::mutex> & lock_a)
 		if (timeout_check)
 		{
 			std::weak_ptr<nano::bootstrap_server> this_w (shared_from_this ());
-			node->workers.add_timed_task (std::chrono::steady_clock::now () + (node->config.tcp_io_timeout * 2) + std::chrono::seconds (1), [this_w]() {
+			node->workers.add_timed_task (std::chrono::steady_clock::now () + (node->config.tcp_io_timeout * 2) + std::chrono::seconds (1), [this_w] () {
 				if (auto this_l = this_w.lock ())
 				{
 					this_l->timeout ();
diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp
index ea1e2ecce7..5524a73633 100644
--- a/nano/node/cli.cpp
+++ b/nano/node/cli.cpp
@@ -675,11 +675,11 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map
 		if (valid_type)
 		{
 			std::cout << "# This is an example configuration file for Nano. Visit https://docs.nano.org/running-a-node/configuration/ for more information.\n#\n"
-			          << "# Fields may need to be defined in the context of a [category] above them.\n"
-			          << "# The desired configuration changes should be placed in config-" << type << ".toml in the node data path.\n"
-			          << "# To change a value from its default, uncomment (erasing #) the corresponding field.\n"
-			          << "# It is not recommended to uncomment every field, as the default value for important fields may change in the future. Only change what you need.\n"
-			          << "# Additional information for notable configuration options is available in https://docs.nano.org/running-a-node/configuration/#notable-configuration-options\n";
+					  << "# Fields may need to be defined in the context of a [category] above them.\n"
+					  << "# The desired configuration changes should be placed in config-" << type << ".toml in the node data path.\n"
+					  << "# To change a value from its default, uncomment (erasing #) the corresponding field.\n"
+					  << "# It is not recommended to uncomment every field, as the default value for important fields may change in the future. Only change what you need.\n"
+					  << "# Additional information for notable configuration options is available in https://docs.nano.org/running-a-node/configuration/#notable-configuration-options\n";
 
 			if (vm.count ("use_defaults"))
 			{
@@ -732,8 +732,8 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map
 	{
 		nano::keypair pair;
 		std::cout << "Private: " << pair.prv.to_string () << std::endl
-		          << "Public: " << pair.pub.to_string () << std::endl
-		          << "Account: " << pair.pub.to_account () << std::endl;
+				  << "Public: " << pair.pub.to_string () << std::endl
+				  << "Account: " << pair.pub.to_account () << std::endl;
 	}
 	else if (vm.count ("key_expand"))
 	{
@@ -743,8 +743,8 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map
 			prv.decode_hex (vm["key"].as<std::string> ());
 			nano::public_key pub (nano::pub_key (prv));
 			std::cout << "Private: " << prv.to_string () << std::endl
-			          << "Public: " << pub.to_string () << std::endl
-			          << "Account: " << pub.to_account () << std::endl;
+					  << "Public: " << pub.to_string () << std::endl
+					  << "Account: " << pub.to_account () << std::endl;
 		}
 		else
 		{
diff --git a/nano/node/common.cpp b/nano/node/common.cpp
index f4fc136bb3..86067c4790 100644
--- a/nano/node/common.cpp
+++ b/nano/node/common.cpp
@@ -50,9 +50,9 @@ uint64_t nano::ip_address_hash_raw (boost::asio::ip::address const & ip_a, uint1
 }
 
 nano::message_header::message_header (nano::message_type type_a) :
-version_max (get_protocol_constants ().protocol_version),
-version_using (get_protocol_constants ().protocol_version),
-type (type_a)
+	version_max (get_protocol_constants ().protocol_version),
+	version_using (get_protocol_constants ().protocol_version),
+	type (type_a)
 {
 }
 
@@ -111,12 +111,12 @@ uint8_t nano::message_header::version_min () const
 }
 
 nano::message::message (nano::message_type type_a) :
-header (type_a)
+	header (type_a)
 {
 }
 
 nano::message::message (nano::message_header const & header_a) :
-header (header_a)
+	header (header_a)
 {
 }
 
@@ -336,12 +336,12 @@ std::string nano::message_parser::status_string ()
 }
 
 nano::message_parser::message_parser (nano::network_filter & publish_filter_a, nano::block_uniquer & block_uniquer_a, nano::vote_uniquer & vote_uniquer_a, nano::message_visitor & visitor_a, nano::work_pool & pool_a) :
-publish_filter (publish_filter_a),
-block_uniquer (block_uniquer_a),
-vote_uniquer (vote_uniquer_a),
-visitor (visitor_a),
-pool (pool_a),
-status (parse_status::success)
+	publish_filter (publish_filter_a),
+	block_uniquer (block_uniquer_a),
+	vote_uniquer (vote_uniquer_a),
+	visitor (visitor_a),
+	pool (pool_a),
+	status (parse_status::success)
 {
 }
 
@@ -558,7 +558,7 @@ bool nano::message_parser::at_end (nano::stream & stream_a)
 }
 
 nano::keepalive::keepalive () :
-message (nano::message_type::keepalive)
+	message (nano::message_type::keepalive)
 {
 	nano::endpoint endpoint (boost::asio::ip::address_v6{}, 0);
 	for (auto i (peers.begin ()), n (peers.end ()); i != n; ++i)
@@ -568,7 +568,7 @@ message (nano::message_type::keepalive)
 }
 
 nano::keepalive::keepalive (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) :
-message (header_a)
+	message (header_a)
 {
 	if (!error_a)
 	{
@@ -619,8 +619,8 @@ bool nano::keepalive::operator== (nano::keepalive const & other_a) const
 }
 
 nano::publish::publish (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a, nano::uint128_t const & digest_a, nano::block_uniquer * uniquer_a) :
-message (header_a),
-digest (digest_a)
+	message (header_a),
+	digest (digest_a)
 {
 	if (!error_a)
 	{
@@ -629,8 +629,8 @@ digest (digest_a)
 }
 
 nano::publish::publish (std::shared_ptr<nano::block> const & block_a) :
-message (nano::message_type::publish),
-block (block_a)
+	message (nano::message_type::publish),
+	block (block_a)
 {
 	header.block_type_set (block->type ());
 }
@@ -661,7 +661,7 @@ bool nano::publish::operator== (nano::publish const & other_a) const
 }
 
 nano::confirm_req::confirm_req (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a, nano::block_uniquer * uniquer_a) :
-message (header_a)
+	message (header_a)
 {
 	if (!error_a)
 	{
@@ -670,15 +670,15 @@ message (header_a)
 }
 
 nano::confirm_req::confirm_req (std::shared_ptr<nano::block> const & block_a) :
-message (nano::message_type::confirm_req),
-block (block_a)
+	message (nano::message_type::confirm_req),
+	block (block_a)
 {
 	header.block_type_set (block->type ());
 }
 
 nano::confirm_req::confirm_req (std::vector<std::pair<nano::block_hash, nano::root>> const & roots_hashes_a) :
-message (nano::message_type::confirm_req),
-roots_hashes (roots_hashes_a)
+	message (nano::message_type::confirm_req),
+	roots_hashes (roots_hashes_a)
 {
 	// not_a_block (1) block type for hashes + roots request
 	header.block_type_set (nano::block_type::not_a_block);
@@ -687,8 +687,8 @@ roots_hashes (roots_hashes_a)
 }
 
 nano::confirm_req::confirm_req (nano::block_hash const & hash_a, nano::root const & root_a) :
-message (nano::message_type::confirm_req),
-roots_hashes (std::vector<std::pair<nano::block_hash, nano::root>> (1, std::make_pair (hash_a, root_a)))
+	message (nano::message_type::confirm_req),
+	roots_hashes (std::vector<std::pair<nano::block_hash, nano::root>> (1, std::make_pair (hash_a, root_a)))
 {
 	debug_assert (!roots_hashes.empty ());
 	// not_a_block (1) block type for hashes + roots request
@@ -801,8 +801,8 @@ size_t nano::confirm_req::size (nano::block_type type_a, size_t count)
 }
 
 nano::confirm_ack::confirm_ack (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a, nano::vote_uniquer * uniquer_a) :
-message (header_a),
-vote (nano::make_shared<nano::vote> (error_a, stream_a, header.block_type ()))
+	message (header_a),
+	vote (nano::make_shared<nano::vote> (error_a, stream_a, header.block_type ()))
 {
 	if (!error_a && uniquer_a)
 	{
@@ -811,8 +811,8 @@ vote (nano::make_shared<nano::vote> (error_a, stream_a, header.block_type ()))
 }
 
 nano::confirm_ack::confirm_ack (std::shared_ptr<nano::vote> const & vote_a) :
-message (nano::message_type::confirm_ack),
-vote (vote_a)
+	message (nano::message_type::confirm_ack),
+	vote (vote_a)
 {
 	debug_assert (!vote_a->blocks.empty ());
 	auto & first_vote_block (vote_a->blocks[0]);
@@ -861,12 +861,12 @@ size_t nano::confirm_ack::size (nano::block_type type_a, size_t count)
 }
 
 nano::frontier_req::frontier_req () :
-message (nano::message_type::frontier_req)
+	message (nano::message_type::frontier_req)
 {
 }
 
 nano::frontier_req::frontier_req (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) :
-message (header_a)
+	message (header_a)
 {
 	if (!error_a)
 	{
@@ -911,12 +911,12 @@ bool nano::frontier_req::operator== (nano::frontier_req const & other_a) const
 }
 
 nano::bulk_pull::bulk_pull () :
-message (nano::message_type::bulk_pull)
+	message (nano::message_type::bulk_pull)
 {
 }
 
 nano::bulk_pull::bulk_pull (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) :
-message (header_a)
+	message (header_a)
 {
 	if (!error_a)
 	{
@@ -1007,12 +1007,12 @@ void nano::bulk_pull::set_count_present (bool value_a)
 }
 
 nano::bulk_pull_account::bulk_pull_account () :
-message (nano::message_type::bulk_pull_account)
+	message (nano::message_type::bulk_pull_account)
 {
 }
 
 nano::bulk_pull_account::bulk_pull_account (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) :
-message (header_a)
+	message (header_a)
 {
 	if (!error_a)
 	{
@@ -1052,12 +1052,12 @@ bool nano::bulk_pull_account::deserialize (nano::stream & stream_a)
 }
 
 nano::bulk_push::bulk_push () :
-message (nano::message_type::bulk_push)
+	message (nano::message_type::bulk_push)
 {
 }
 
 nano::bulk_push::bulk_push (nano::message_header const & header_a) :
-message (header_a)
+	message (header_a)
 {
 }
 
@@ -1078,12 +1078,12 @@ void nano::bulk_push::visit (nano::message_visitor & visitor_a) const
 }
 
 nano::telemetry_req::telemetry_req () :
-message (nano::message_type::telemetry_req)
+	message (nano::message_type::telemetry_req)
 {
 }
 
 nano::telemetry_req::telemetry_req (nano::message_header const & header_a) :
-message (header_a)
+	message (header_a)
 {
 }
 
@@ -1104,12 +1104,12 @@ void nano::telemetry_req::visit (nano::message_visitor & visitor_a) const
 }
 
 nano::telemetry_ack::telemetry_ack () :
-message (nano::message_type::telemetry_ack)
+	message (nano::message_type::telemetry_ack)
 {
 }
 
 nano::telemetry_ack::telemetry_ack (bool & error_a, nano::stream & stream_a, nano::message_header const & message_header) :
-message (message_header)
+	message (message_header)
 {
 	if (!error_a)
 	{
@@ -1118,8 +1118,8 @@ message (message_header)
 }
 
 nano::telemetry_ack::telemetry_ack (nano::telemetry_data const & telemetry_data_a) :
-message (nano::message_type::telemetry_ack),
-data (telemetry_data_a)
+	message (nano::message_type::telemetry_ack),
+	data (telemetry_data_a)
 {
 	debug_assert (telemetry_data::size + telemetry_data_a.unknown_data.size () <= message_header::telemetry_size_mask.to_ulong ()); // Maximum size the mask allows
 	header.extensions &= ~message_header::telemetry_size_mask;
@@ -1357,17 +1357,17 @@ bool nano::telemetry_data::validate_signature () const
 }
 
 nano::node_id_handshake::node_id_handshake (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) :
-message (header_a),
-query (boost::none),
-response (boost::none)
+	message (header_a),
+	query (boost::none),
+	response (boost::none)
 {
 	error_a = deserialize (stream_a);
 }
 
 nano::node_id_handshake::node_id_handshake (boost::optional<nano::uint256_union> query, boost::optional<std::pair<nano::account, nano::signature>> response) :
-message (nano::message_type::node_id_handshake),
-query (query),
-response (response)
+	message (nano::message_type::node_id_handshake),
+	query (query),
+	response (response)
 {
 	if (query)
 	{
@@ -1558,6 +1558,6 @@ std::chrono::seconds nano::telemetry_cache_cutoffs::network_to_time (network_con
 }
 
 nano::node_singleton_memory_pool_purge_guard::node_singleton_memory_pool_purge_guard () :
-cleanup_guard ({ nano::block_memory_pool_purge, nano::purge_shared_ptr_singleton_pool_memory<nano::vote>, nano::purge_shared_ptr_singleton_pool_memory<nano::election>, nano::purge_singleton_inactive_votes_cache_pool_memory })
+	cleanup_guard ({ nano::block_memory_pool_purge, nano::purge_shared_ptr_singleton_pool_memory<nano::vote>, nano::purge_shared_ptr_singleton_pool_memory<nano::election>, nano::purge_singleton_inactive_votes_cache_pool_memory })
 {
 }
diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp
index b3ff2d2739..e6803f14c5 100644
--- a/nano/node/confirmation_height_bounded.cpp
+++ b/nano/node/confirmation_height_bounded.cpp
@@ -11,16 +11,16 @@
 #include <numeric>
 
 nano::confirmation_height_bounded::confirmation_height_bounded (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logging const & logging_a, nano::logger_mt & logger_a, std::atomic<bool> & stopped_a, uint64_t & batch_write_size_a, std::function<void (std::vector<std::shared_ptr<nano::block>> const &)> const & notify_observers_callback_a, std::function<void (nano::block_hash const &)> const & notify_block_already_cemented_observers_callback_a, std::function<uint64_t ()> const & awaiting_processing_size_callback_a) :
-ledger (ledger_a),
-write_database_queue (write_database_queue_a),
-batch_separate_pending_min_time (batch_separate_pending_min_time_a),
-logging (logging_a),
-logger (logger_a),
-stopped (stopped_a),
-batch_write_size (batch_write_size_a),
-notify_observers_callback (notify_observers_callback_a),
-notify_block_already_cemented_observers_callback (notify_block_already_cemented_observers_callback_a),
-awaiting_processing_size_callback (awaiting_processing_size_callback_a)
+	ledger (ledger_a),
+	write_database_queue (write_database_queue_a),
+	batch_separate_pending_min_time (batch_separate_pending_min_time_a),
+	logging (logging_a),
+	logger (logger_a),
+	stopped (stopped_a),
+	batch_write_size (batch_write_size_a),
+	notify_observers_callback (notify_observers_callback_a),
+	notify_block_already_cemented_observers_callback (notify_block_already_cemented_observers_callback_a),
+	awaiting_processing_size_callback (awaiting_processing_size_callback_a)
 {
 }
 
@@ -561,34 +561,34 @@ void nano::confirmation_height_bounded::clear_process_vars ()
 }
 
 nano::confirmation_height_bounded::receive_chain_details::receive_chain_details (nano::account const & account_a, uint64_t height_a, nano::block_hash const & hash_a, nano::block_hash const & top_level_a, boost::optional<nano::block_hash> next_a, uint64_t bottom_height_a, nano::block_hash const & bottom_most_a) :
-account (account_a),
-height (height_a),
-hash (hash_a),
-top_level (top_level_a),
-next (next_a),
-bottom_height (bottom_height_a),
-bottom_most (bottom_most_a)
+	account (account_a),
+	height (height_a),
+	hash (hash_a),
+	top_level (top_level_a),
+	next (next_a),
+	bottom_height (bottom_height_a),
+	bottom_most (bottom_most_a)
 {
 }
 
 nano::confirmation_height_bounded::write_details::write_details (nano::account const & account_a, uint64_t bottom_height_a, nano::block_hash const & bottom_hash_a, uint64_t top_height_a, nano::block_hash const & top_hash_a) :
-account (account_a),
-bottom_height (bottom_height_a),
-bottom_hash (bottom_hash_a),
-top_height (top_height_a),
-top_hash (top_hash_a)
+	account (account_a),
+	bottom_height (bottom_height_a),
+	bottom_hash (bottom_hash_a),
+	top_height (top_height_a),
+	top_hash (top_hash_a)
 {
 }
 
 nano::confirmation_height_bounded::receive_source_pair::receive_source_pair (confirmation_height_bounded::receive_chain_details const & receive_details_a, const block_hash & source_a) :
-receive_details (receive_details_a),
-source_hash (source_a)
+	receive_details (receive_details_a),
+	source_hash (source_a)
 {
 }
 
 nano::confirmation_height_bounded::confirmed_info::confirmed_info (uint64_t confirmed_height_a, nano::block_hash const & iterated_frontier_a) :
-confirmed_height (confirmed_height_a),
-iterated_frontier (iterated_frontier_a)
+	confirmed_height (confirmed_height_a),
+	iterated_frontier (iterated_frontier_a)
 {
 }
 
diff --git a/nano/node/confirmation_height_processor.cpp b/nano/node/confirmation_height_processor.cpp
index 1708975f6b..8c99a59a22 100644
--- a/nano/node/confirmation_height_processor.cpp
+++ b/nano/node/confirmation_height_processor.cpp
@@ -12,18 +12,18 @@
 #include <numeric>
 
 nano::confirmation_height_processor::confirmation_height_processor (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logging const & logging_a, nano::logger_mt & logger_a, boost::latch & latch, confirmation_height_mode mode_a) :
-ledger (ledger_a),
-write_database_queue (write_database_queue_a),
-// clang-format off
+	ledger (ledger_a),
+	write_database_queue (write_database_queue_a),
+	// clang-format off
 unbounded_processor (ledger_a, write_database_queue_a, batch_separate_pending_min_time_a, logging_a, logger_a, stopped, batch_write_size, [this](auto & cemented_blocks) { this->notify_observers (cemented_blocks); }, [this](auto const & block_hash_a) { this->notify_observers (block_hash_a); }, [this]() { return this->awaiting_processing_size (); }),
 bounded_processor (ledger_a, write_database_queue_a, batch_separate_pending_min_time_a, logging_a, logger_a, stopped, batch_write_size, [this](auto & cemented_blocks) { this->notify_observers (cemented_blocks); }, [this](auto const & block_hash_a) { this->notify_observers (block_hash_a); }, [this]() { return this->awaiting_processing_size (); }),
-// clang-format on
-thread ([this, &latch, mode_a] () {
-	nano::thread_role::set (nano::thread_role::name::confirmation_height_processing);
-	// Do not start running the processing thread until other threads have finished their operations
-	latch.wait ();
-	this->run (mode_a);
-})
+	// clang-format on
+	thread ([this, &latch, mode_a] () {
+		nano::thread_role::set (nano::thread_role::name::confirmation_height_processing);
+		// Do not start running the processing thread until other threads have finished their operations
+		latch.wait ();
+		this->run (mode_a);
+	})
 {
 }
 
diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp
index ab11552435..38b835ac02 100644
--- a/nano/node/confirmation_height_unbounded.cpp
+++ b/nano/node/confirmation_height_unbounded.cpp
@@ -9,16 +9,16 @@
 #include <numeric>
 
 nano::confirmation_height_unbounded::confirmation_height_unbounded (nano::ledger & ledger_a, nano::write_database_queue & write_database_queue_a, std::chrono::milliseconds batch_separate_pending_min_time_a, nano::logging const & logging_a, nano::logger_mt & logger_a, std::atomic<bool> & stopped_a, uint64_t & batch_write_size_a, std::function<void (std::vector<std::shared_ptr<nano::block>> const &)> const & notify_observers_callback_a, std::function<void (nano::block_hash const &)> const & notify_block_already_cemented_observers_callback_a, std::function<uint64_t ()> const & awaiting_processing_size_callback_a) :
-ledger (ledger_a),
-write_database_queue (write_database_queue_a),
-batch_separate_pending_min_time (batch_separate_pending_min_time_a),
-logging (logging_a),
-logger (logger_a),
-stopped (stopped_a),
-batch_write_size (batch_write_size_a),
-notify_observers_callback (notify_observers_callback_a),
-notify_block_already_cemented_observers_callback (notify_block_already_cemented_observers_callback_a),
-awaiting_processing_size_callback (awaiting_processing_size_callback_a)
+	ledger (ledger_a),
+	write_database_queue (write_database_queue_a),
+	batch_separate_pending_min_time (batch_separate_pending_min_time_a),
+	logging (logging_a),
+	logger (logger_a),
+	stopped (stopped_a),
+	batch_write_size (batch_write_size_a),
+	notify_observers_callback (notify_observers_callback_a),
+	notify_block_already_cemented_observers_callback (notify_block_already_cemented_observers_callback_a),
+	awaiting_processing_size_callback (awaiting_processing_size_callback_a)
 {
 }
 
@@ -485,23 +485,23 @@ uint64_t nano::confirmation_height_unbounded::block_cache_size () const
 }
 
 nano::confirmation_height_unbounded::conf_height_details::conf_height_details (nano::account const & account_a, nano::block_hash const & hash_a, uint64_t height_a, uint64_t num_blocks_confirmed_a, std::vector<nano::block_hash> const & block_callback_data_a) :
-account (account_a),
-hash (hash_a),
-height (height_a),
-num_blocks_confirmed (num_blocks_confirmed_a),
-block_callback_data (block_callback_data_a)
+	account (account_a),
+	hash (hash_a),
+	height (height_a),
+	num_blocks_confirmed (num_blocks_confirmed_a),
+	block_callback_data (block_callback_data_a)
 {
 }
 
 nano::confirmation_height_unbounded::receive_source_pair::receive_source_pair (std::shared_ptr<conf_height_details> const & receive_details_a, const block_hash & source_a) :
-receive_details (receive_details_a),
-source_hash (source_a)
+	receive_details (receive_details_a),
+	source_hash (source_a)
 {
 }
 
 nano::confirmation_height_unbounded::confirmed_iterated_pair::confirmed_iterated_pair (uint64_t confirmed_height_a, uint64_t iterated_height_a) :
-confirmed_height (confirmed_height_a),
-iterated_height (iterated_height_a)
+	confirmed_height (confirmed_height_a),
+	iterated_height (iterated_height_a)
 {
 }
 
diff --git a/nano/node/confirmation_solicitor.cpp b/nano/node/confirmation_solicitor.cpp
index 79e97a41f1..f7f702dc75 100644
--- a/nano/node/confirmation_solicitor.cpp
+++ b/nano/node/confirmation_solicitor.cpp
@@ -5,11 +5,11 @@
 using namespace std::chrono_literals;
 
 nano::confirmation_solicitor::confirmation_solicitor (nano::network & network_a, nano::node_config const & config_a) :
-max_block_broadcasts (config_a.network_params.network.is_dev_network () ? 4 : 30),
-max_election_requests (50),
-max_election_broadcasts (std::max<size_t> (network_a.fanout () / 2, 1)),
-network (network_a),
-config (config_a)
+	max_block_broadcasts (config_a.network_params.network.is_dev_network () ? 4 : 30),
+	max_election_requests (50),
+	max_election_broadcasts (std::max<size_t> (network_a.fanout () / 2, 1)),
+	network (network_a),
+	config (config_a)
 {
 }
 
diff --git a/nano/node/daemonconfig.cpp b/nano/node/daemonconfig.cpp
index c12d7695a4..5706dad305 100644
--- a/nano/node/daemonconfig.cpp
+++ b/nano/node/daemonconfig.cpp
@@ -8,7 +8,7 @@
 #include <vector>
 
 nano::daemon_config::daemon_config (boost::filesystem::path const & data_path_a) :
-data_path (data_path_a)
+	data_path (data_path_a)
 {
 }
 
@@ -144,8 +144,8 @@ nano::error nano::read_node_config_toml (boost::filesystem::path const & data_pa
 		if (boost::filesystem::exists (toml_config_path))
 		{
 			error = "Both json and toml node configuration files exists. "
-			        "Either remove the config.json file and restart, or remove "
-			        "the config-node.toml file to start migration on next launch.";
+					"Either remove the config.json file and restart, or remove "
+					"the config-node.toml file to start migration on next launch.";
 		}
 		else
 		{
diff --git a/nano/node/distributed_work.cpp b/nano/node/distributed_work.cpp
index 00fcfc9f08..540459d66d 100644
--- a/nano/node/distributed_work.cpp
+++ b/nano/node/distributed_work.cpp
@@ -21,13 +21,13 @@ std::shared_ptr<request_type> nano::distributed_work::peer_request::get_prepared
 }
 
 nano::distributed_work::distributed_work (nano::node & node_a, nano::work_request const & request_a, std::chrono::seconds const & backoff_a) :
-node (node_a),
-node_w (node_a.shared ()),
-request (request_a),
-backoff (backoff_a),
-strand (node_a.io_ctx.get_executor ()),
-need_resolve (request_a.peers),
-elapsed (nano::timer_state::started, "distributed work generation timer")
+	node (node_a),
+	node_w (node_a.shared ()),
+	request (request_a),
+	backoff (backoff_a),
+	strand (node_a.io_ctx.get_executor ()),
+	need_resolve (request_a.peers),
+	elapsed (nano::timer_state::started, "distributed work generation timer")
 {
 	debug_assert (!finished);
 	debug_assert (status == work_generation_status::ongoing);
@@ -82,7 +82,7 @@ void nano::distributed_work::start ()
 		else
 		{
 			auto this_l (shared_from_this ());
-			node.network.resolver.async_resolve (boost::asio::ip::udp::resolver::query (peer.first, std::to_string (peer.second)), [peer, this_l, &extra = resolved_extra](boost::system::error_code const & ec, boost::asio::ip::udp::resolver::iterator i_a) {
+			node.network.resolver.async_resolve (boost::asio::ip::udp::resolver::query (peer.first, std::to_string (peer.second)), [peer, this_l, &extra = resolved_extra] (boost::system::error_code const & ec, boost::asio::ip::udp::resolver::iterator i_a) {
 				if (!ec)
 				{
 					this_l->do_request (nano::tcp_endpoint (i_a->endpoint ().address (), i_a->endpoint ().port ()));
@@ -107,7 +107,7 @@ void nano::distributed_work::start_local ()
 {
 	auto this_l (shared_from_this ());
 	local_generation_started = true;
-	node.work.generate (request.version, request.root, request.difficulty, [this_l](boost::optional<uint64_t> const & work_a) {
+	node.work.generate (request.version, request.root, request.difficulty, [this_l] (boost::optional<uint64_t> const & work_a) {
 		if (work_a.is_initialized ())
 		{
 			this_l->set_once (*work_a);
@@ -134,7 +134,7 @@ void nano::distributed_work::do_request (nano::tcp_endpoint const & endpoint_a)
 	}
 	connection->socket.async_connect (connection->endpoint,
 	boost::asio::bind_executor (strand,
-	[this_l, connection](boost::system::error_code const & ec) {
+	[this_l, connection] (boost::system::error_code const & ec) {
 		if (!ec && !this_l->stopped)
 		{
 			std::string request_string;
@@ -154,11 +154,11 @@ void nano::distributed_work::do_request (nano::tcp_endpoint const & endpoint_a)
 			auto peer_request (connection->get_prepared_json_request (request_string));
 			boost::beast::http::async_write (connection->socket, *peer_request,
 			boost::asio::bind_executor (this_l->strand,
-			[this_l, connection, peer_request](boost::system::error_code const & ec, size_t size_a) {
+			[this_l, connection, peer_request] (boost::system::error_code const & ec, size_t size_a) {
 				if (!ec && !this_l->stopped)
 				{
 					boost::beast::http::async_read (connection->socket, connection->buffer, connection->response,
-					boost::asio::bind_executor (this_l->strand, [this_l, connection](boost::system::error_code const & ec, size_t size_a) {
+					boost::asio::bind_executor (this_l->strand, [this_l, connection] (boost::system::error_code const & ec, size_t size_a) {
 						if (!ec && !this_l->stopped)
 						{
 							if (connection->response.result () == boost::beast::http::status::ok)
@@ -202,7 +202,7 @@ void nano::distributed_work::do_cancel (nano::tcp_endpoint const & endpoint_a)
 	auto cancelling_l (std::make_shared<peer_request> (node.io_ctx, endpoint_a));
 	cancelling_l->socket.async_connect (cancelling_l->endpoint,
 	boost::asio::bind_executor (strand,
-	[this_l, cancelling_l](boost::system::error_code const & ec) {
+	[this_l, cancelling_l] (boost::system::error_code const & ec) {
 		if (!ec)
 		{
 			std::string request_string;
@@ -217,7 +217,7 @@ void nano::distributed_work::do_cancel (nano::tcp_endpoint const & endpoint_a)
 			auto peer_cancel (cancelling_l->get_prepared_json_request (request_string));
 			boost::beast::http::async_write (cancelling_l->socket, *peer_cancel,
 			boost::asio::bind_executor (this_l->strand,
-			[this_l, peer_cancel, cancelling_l](boost::system::error_code const & ec, size_t bytes_transferred) {
+			[this_l, peer_cancel, cancelling_l] (boost::system::error_code const & ec, size_t bytes_transferred) {
 				if (ec && ec != boost::system::errc::operation_canceled)
 				{
 					this_l->node.logger.try_log (boost::str (boost::format ("Unable to send work_cancel to work_peer %1% %2%: %3% (%4%)") % cancelling_l->endpoint.address () % cancelling_l->endpoint.port () % ec.message () % ec.value ()));
diff --git a/nano/node/distributed_work.hpp b/nano/node/distributed_work.hpp
index eb0e916686..2dcf11ceef 100644
--- a/nano/node/distributed_work.hpp
+++ b/nano/node/distributed_work.hpp
@@ -33,7 +33,7 @@ struct work_request final
 	nano::root root;
 	uint64_t difficulty;
 	boost::optional<nano::account> const account;
-	std::function<void(boost::optional<uint64_t>)> callback;
+	std::function<void (boost::optional<uint64_t>)> callback;
 	std::vector<std::pair<std::string, uint16_t>> const peers;
 };
 
@@ -55,8 +55,8 @@ class distributed_work final : public std::enable_shared_from_this<nano::distrib
 	{
 	public:
 		peer_request (boost::asio::io_context & io_ctx_a, nano::tcp_endpoint const & endpoint_a) :
-		endpoint (endpoint_a),
-		socket (io_ctx_a)
+			endpoint (endpoint_a),
+			socket (io_ctx_a)
 		{
 		}
 		std::shared_ptr<request_type> get_prepared_json_request (std::string const &) const;
diff --git a/nano/node/distributed_work_factory.cpp b/nano/node/distributed_work_factory.cpp
index 307e62115d..d7167bc601 100644
--- a/nano/node/distributed_work_factory.cpp
+++ b/nano/node/distributed_work_factory.cpp
@@ -3,7 +3,7 @@
 #include <nano/node/node.hpp>
 
 nano::distributed_work_factory::distributed_work_factory (nano::node & node_a) :
-node (node_a)
+	node (node_a)
 {
 }
 
@@ -12,7 +12,7 @@ nano::distributed_work_factory::~distributed_work_factory ()
 	stop ();
 }
 
-bool nano::distributed_work_factory::make (nano::work_version const version_a, nano::root const & root_a, std::vector<std::pair<std::string, uint16_t>> const & peers_a, uint64_t difficulty_a, std::function<void(boost::optional<uint64_t>)> const & callback_a, boost::optional<nano::account> const & account_a)
+bool nano::distributed_work_factory::make (nano::work_version const version_a, nano::root const & root_a, std::vector<std::pair<std::string, uint16_t>> const & peers_a, uint64_t difficulty_a, std::function<void (boost::optional<uint64_t>)> const & callback_a, boost::optional<nano::account> const & account_a)
 {
 	return make (std::chrono::seconds (1), nano::work_request{ version_a, root_a, difficulty_a, account_a, callback_a, peers_a });
 }
@@ -41,7 +41,7 @@ void nano::distributed_work_factory::cancel (nano::root const & root_a)
 {
 	nano::lock_guard<nano::mutex> guard_l (mutex);
 	auto root_items_l = items.equal_range (root_a);
-	std::for_each (root_items_l.first, root_items_l.second, [](auto item_l) {
+	std::for_each (root_items_l.first, root_items_l.second, [] (auto item_l) {
 		if (auto distributed_l = item_l.second.lock ())
 		{
 			// Send work_cancel to work peers and stop local work generation
@@ -55,7 +55,7 @@ void nano::distributed_work_factory::cleanup_finished ()
 {
 	nano::lock_guard<nano::mutex> guard (mutex);
 	// std::erase_if in c++20
-	auto erase_if = [](decltype (items) & container, auto pred) {
+	auto erase_if = [] (decltype (items) & container, auto pred) {
 		for (auto it = container.begin (), end = container.end (); it != end;)
 		{
 			if (pred (*it))
@@ -68,7 +68,7 @@ void nano::distributed_work_factory::cleanup_finished ()
 			}
 		}
 	};
-	erase_if (items, [](decltype (items)::value_type item) { return item.second.expired (); });
+	erase_if (items, [] (decltype (items)::value_type item) { return item.second.expired (); });
 }
 
 void nano::distributed_work_factory::stop ()
diff --git a/nano/node/distributed_work_factory.hpp b/nano/node/distributed_work_factory.hpp
index 7c626b2834..bd5bcf022a 100644
--- a/nano/node/distributed_work_factory.hpp
+++ b/nano/node/distributed_work_factory.hpp
@@ -21,7 +21,7 @@ class distributed_work_factory final
 public:
 	distributed_work_factory (nano::node &);
 	~distributed_work_factory ();
-	bool make (nano::work_version const, nano::root const &, std::vector<std::pair<std::string, uint16_t>> const &, uint64_t, std::function<void(boost::optional<uint64_t>)> const &, boost::optional<nano::account> const & = boost::none);
+	bool make (nano::work_version const, nano::root const &, std::vector<std::pair<std::string, uint16_t>> const &, uint64_t, std::function<void (boost::optional<uint64_t>)> const &, boost::optional<nano::account> const & = boost::none);
 	bool make (std::chrono::seconds const &, nano::work_request const &);
 	void cancel (nano::root const &);
 	void cleanup_finished ();
diff --git a/nano/node/election.cpp b/nano/node/election.cpp
index 5efb24c6f5..5b1fee6b41 100644
--- a/nano/node/election.cpp
+++ b/nano/node/election.cpp
@@ -19,15 +19,15 @@ nano::election_vote_result::election_vote_result (bool replay_a, bool processed_
 }
 
 nano::election::election (nano::node & node_a, std::shared_ptr<nano::block> const & block_a, std::function<void (std::shared_ptr<nano::block> const &)> const & confirmation_action_a, std::function<void (nano::account const &)> const & live_vote_action_a, bool prioritized_a, nano::election_behavior election_behavior_a) :
-confirmation_action (confirmation_action_a),
-live_vote_action (live_vote_action_a),
-prioritized_m (prioritized_a),
-behavior (election_behavior_a),
-node (node_a),
-status ({ block_a, 0, std::chrono::duration_cast<std::chrono::milliseconds> (std::chrono::system_clock::now ().time_since_epoch ()), std::chrono::duration_values<std::chrono::milliseconds>::zero (), 0, 1, 0, nano::election_status_type::ongoing }),
-height (block_a->sideband ().height),
-root (block_a->root ()),
-qualified_root (block_a->qualified_root ())
+	confirmation_action (confirmation_action_a),
+	live_vote_action (live_vote_action_a),
+	prioritized_m (prioritized_a),
+	behavior (election_behavior_a),
+	node (node_a),
+	status ({ block_a, 0, std::chrono::duration_cast<std::chrono::milliseconds> (std::chrono::system_clock::now ().time_since_epoch ()), std::chrono::duration_values<std::chrono::milliseconds>::zero (), 0, 1, 0, nano::election_status_type::ongoing }),
+	height (block_a->sideband ().height),
+	root (block_a->root ()),
+	qualified_root (block_a->qualified_root ())
 {
 	last_votes.emplace (node.network_params.random.not_an_account, nano::vote_info{ std::chrono::steady_clock::now (), 0, block_a->hash () });
 	last_blocks.emplace (block_a->hash (), block_a);
diff --git a/nano/node/election.hpp b/nano/node/election.hpp
index a215448b83..b638d25a36 100644
--- a/nano/node/election.hpp
+++ b/nano/node/election.hpp
@@ -62,8 +62,8 @@ class election final : public std::enable_shared_from_this<nano::election>
 {
 	// Minimum time between broadcasts of the current winner of an election, as a backup to requesting confirmations
 	std::chrono::milliseconds base_latency () const;
-	std::function<void(std::shared_ptr<nano::block> const &)> confirmation_action;
-	std::function<void(nano::account const &)> live_vote_action;
+	std::function<void (std::shared_ptr<nano::block> const &)> confirmation_action;
+	std::function<void (nano::account const &)> live_vote_action;
 
 private: // State management
 	enum class state_t
@@ -111,7 +111,7 @@ class election final : public std::enable_shared_from_this<nano::election>
 	nano::election_status status;
 
 public: // Interface
-	election (nano::node &, std::shared_ptr<nano::block> const &, std::function<void(std::shared_ptr<nano::block> const &)> const &, std::function<void(nano::account const &)> const &, bool, nano::election_behavior);
+	election (nano::node &, std::shared_ptr<nano::block> const &, std::function<void (std::shared_ptr<nano::block> const &)> const &, std::function<void (nano::account const &)> const &, bool, nano::election_behavior);
 	std::shared_ptr<nano::block> find (nano::block_hash const &) const;
 	nano::election_vote_result vote (nano::account const &, uint64_t, nano::block_hash const &);
 	bool publish (std::shared_ptr<nano::block> const & block_a);
diff --git a/nano/node/gap_cache.cpp b/nano/node/gap_cache.cpp
index e76f858a18..6db03b8e42 100644
--- a/nano/node/gap_cache.cpp
+++ b/nano/node/gap_cache.cpp
@@ -5,7 +5,7 @@
 #include <boost/format.hpp>
 
 nano::gap_cache::gap_cache (nano::node & node_a) :
-node (node_a)
+	node (node_a)
 {
 }
 
@@ -15,7 +15,7 @@ void nano::gap_cache::add (nano::block_hash const & hash_a, std::chrono::steady_
 	auto existing (blocks.get<tag_hash> ().find (hash_a));
 	if (existing != blocks.get<tag_hash> ().end ())
 	{
-		blocks.get<tag_hash> ().modify (existing, [time_point_a](nano::gap_information & info) {
+		blocks.get<tag_hash> ().modify (existing, [time_point_a] (nano::gap_information & info) {
 			info.arrival = time_point_a;
 		});
 	}
@@ -45,7 +45,7 @@ void nano::gap_cache::vote (std::shared_ptr<nano::vote> const & vote_a)
 		if (existing != gap_blocks_by_hash.end () && !existing->bootstrap_started)
 		{
 			auto is_new (false);
-			gap_blocks_by_hash.modify (existing, [&is_new, &vote_a](nano::gap_information & info) {
+			gap_blocks_by_hash.modify (existing, [&is_new, &vote_a] (nano::gap_information & info) {
 				auto it = std::find (info.voters.begin (), info.voters.end (), vote_a->account);
 				is_new = (it == info.voters.end ());
 				if (is_new)
@@ -58,7 +58,7 @@ void nano::gap_cache::vote (std::shared_ptr<nano::vote> const & vote_a)
 			{
 				if (bootstrap_check (existing->voters, hash))
 				{
-					gap_blocks_by_hash.modify (existing, [](nano::gap_information & info) {
+					gap_blocks_by_hash.modify (existing, [] (nano::gap_information & info) {
 						info.bootstrap_started = true;
 					});
 				}
@@ -96,7 +96,7 @@ bool nano::gap_cache::bootstrap_check (std::vector<nano::account> const & voters
 void nano::gap_cache::bootstrap_start (nano::block_hash const & hash_a)
 {
 	auto node_l (node.shared ());
-	node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.bootstrap.gap_cache_bootstrap_start_interval, [node_l, hash_a]() {
+	node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.bootstrap.gap_cache_bootstrap_start_interval, [node_l, hash_a] () {
 		if (!node_l->ledger.block_or_pruned_exists (hash_a))
 		{
 			if (!node_l->bootstrap_initiator.in_progress ())
diff --git a/nano/node/ipc/action_handler.cpp b/nano/node/ipc/action_handler.cpp
index 3e4a1a4d0c..76086e737c 100644
--- a/nano/node/ipc/action_handler.cpp
+++ b/nano/node/ipc/action_handler.cpp
@@ -40,9 +40,9 @@ auto get_message (nanoapi::Envelope const & envelope)
  * Mapping from message type to handler function.
  * @note This must be updated whenever a new message type is added to the Flatbuffers IDL.
  */
-auto nano::ipc::action_handler::handler_map () -> std::unordered_map<nanoapi::Message, std::function<void(nano::ipc::action_handler *, nanoapi::Envelope const &)>, nano::ipc::enum_hash>
+auto nano::ipc::action_handler::handler_map () -> std::unordered_map<nanoapi::Message, std::function<void (nano::ipc::action_handler *, nanoapi::Envelope const &)>, nano::ipc::enum_hash>
 {
-	static std::unordered_map<nanoapi::Message, std::function<void(nano::ipc::action_handler *, nanoapi::Envelope const &)>, nano::ipc::enum_hash> handlers;
+	static std::unordered_map<nanoapi::Message, std::function<void (nano::ipc::action_handler *, nanoapi::Envelope const &)>, nano::ipc::enum_hash> handlers;
 	if (handlers.empty ())
 	{
 		handlers.emplace (nanoapi::Message::Message_IsAlive, &nano::ipc::action_handler::on_is_alive);
@@ -56,10 +56,10 @@ auto nano::ipc::action_handler::handler_map () -> std::unordered_map<nanoapi::Me
 }
 
 nano::ipc::action_handler::action_handler (nano::node & node_a, nano::ipc::ipc_server & server_a, std::weak_ptr<nano::ipc::subscriber> const & subscriber_a, std::shared_ptr<flatbuffers::FlatBufferBuilder> const & builder_a) :
-flatbuffer_producer (builder_a),
-node (node_a),
-ipc_server (server_a),
-subscriber (subscriber_a)
+	flatbuffer_producer (builder_a),
+	node (node_a),
+	ipc_server (server_a),
+	subscriber (subscriber_a)
 {
 }
 
diff --git a/nano/node/ipc/action_handler.hpp b/nano/node/ipc/action_handler.hpp
index 63c51c57a9..2c84259010 100644
--- a/nano/node/ipc/action_handler.hpp
+++ b/nano/node/ipc/action_handler.hpp
@@ -53,7 +53,7 @@ namespace ipc
 		void on_topic_service_stop (nanoapi::Envelope const & envelope);
 
 		/** Returns a mapping from api message types to handler functions */
-		static auto handler_map () -> std::unordered_map<nanoapi::Message, std::function<void(action_handler *, nanoapi::Envelope const &)>, nano::ipc::enum_hash>;
+		static auto handler_map () -> std::unordered_map<nanoapi::Message, std::function<void (action_handler *, nanoapi::Envelope const &)>, nano::ipc::enum_hash>;
 
 	private:
 		bool has_access (nanoapi::Envelope const & envelope_a, nano::ipc::access_permission permission_a) const noexcept;
diff --git a/nano/node/ipc/flatbuffers_handler.cpp b/nano/node/ipc/flatbuffers_handler.cpp
index f47a479010..ca91f527a9 100644
--- a/nano/node/ipc/flatbuffers_handler.cpp
+++ b/nano/node/ipc/flatbuffers_handler.cpp
@@ -28,8 +28,8 @@ std::string make_error_response (std::string const & error_message)
 {
 	std::ostringstream json;
 	json << R"json({"message_type": "Error", "message": {"code": 1, "message": ")json"
-	     << error_message
-	     << R"json("}})json";
+		 << error_message
+		 << R"json("}})json";
 	return json.str ();
 }
 
@@ -58,10 +58,10 @@ boost::optional<boost::filesystem::path> get_api_path ()
 }
 
 nano::ipc::flatbuffers_handler::flatbuffers_handler (nano::node & node_a, nano::ipc::ipc_server & ipc_server_a, std::shared_ptr<nano::ipc::subscriber> const & subscriber_a, nano::ipc::ipc_config const & ipc_config_a) :
-node (node_a),
-ipc_server (ipc_server_a),
-subscriber (subscriber_a),
-ipc_config (ipc_config_a)
+	node (node_a),
+	ipc_server (ipc_server_a),
+	subscriber (subscriber_a),
+	ipc_config (ipc_config_a)
 {
 }
 
@@ -95,7 +95,7 @@ std::shared_ptr<flatbuffers::Parser> nano::ipc::flatbuffers_handler::make_flatbu
 }
 
 void nano::ipc::flatbuffers_handler::process_json (const uint8_t * message_buffer_a, size_t buffer_size_a,
-std::function<void(std::shared_ptr<std::string> const &)> const & response_handler)
+std::function<void (std::shared_ptr<std::string> const &)> const & response_handler)
 {
 	try
 	{
@@ -109,7 +109,7 @@ std::function<void(std::shared_ptr<std::string> const &)> const & response_handl
 		body += '\0';
 		if (parser->Parse (reinterpret_cast<const char *> (body.data ())))
 		{
-			process (parser->builder_.GetBufferPointer (), parser->builder_.GetSize (), [parser = parser, response_handler](std::shared_ptr<flatbuffers::FlatBufferBuilder> const & fbb) {
+			process (parser->builder_.GetBufferPointer (), parser->builder_.GetSize (), [parser = parser, response_handler] (std::shared_ptr<flatbuffers::FlatBufferBuilder> const & fbb) {
 				// Convert response to JSON
 				auto json (std::make_shared<std::string> ());
 				if (!flatbuffers::GenerateText (*parser, fbb->GetBufferPointer (), json.get ()))
@@ -145,7 +145,7 @@ std::function<void(std::shared_ptr<std::string> const &)> const & response_handl
 }
 
 void nano::ipc::flatbuffers_handler::process (const uint8_t * message_buffer_a, size_t buffer_size_a,
-std::function<void(std::shared_ptr<flatbuffers::FlatBufferBuilder> const &)> const & response_handler)
+std::function<void (std::shared_ptr<flatbuffers::FlatBufferBuilder> const &)> const & response_handler)
 {
 	auto buffer_l (std::make_shared<flatbuffers::FlatBufferBuilder> ());
 	auto actionhandler (std::make_shared<action_handler> (node, ipc_server, subscriber, buffer_l));
diff --git a/nano/node/ipc/flatbuffers_handler.hpp b/nano/node/ipc/flatbuffers_handler.hpp
index 4a2954a997..ac588e3191 100644
--- a/nano/node/ipc/flatbuffers_handler.hpp
+++ b/nano/node/ipc/flatbuffers_handler.hpp
@@ -42,12 +42,12 @@ namespace ipc
 		 * @param response_handler Receives a shared pointer to the flatbuffer builder, from which the buffer and size can be queried
 		 * @throw Throws std:runtime_error on deserialization or processing errors
 		 */
-		void process (const uint8_t * message_buffer_a, size_t buffer_size_a, std::function<void(std::shared_ptr<flatbuffers::FlatBufferBuilder> const &)> const & response_handler);
+		void process (const uint8_t * message_buffer_a, size_t buffer_size_a, std::function<void (std::shared_ptr<flatbuffers::FlatBufferBuilder> const &)> const & response_handler);
 
 		/**
 		 * Parses a JSON encoded requests into Flatbuffer format, calls process(), yields the result as a JSON string
 		 */
-		void process_json (const uint8_t * message_buffer_a, size_t buffer_size_a, std::function<void(std::shared_ptr<std::string> const &)> const & response_handler);
+		void process_json (const uint8_t * message_buffer_a, size_t buffer_size_a, std::function<void (std::shared_ptr<std::string> const &)> const & response_handler);
 
 		/**
 		 * Creates a Flatbuffers parser with the schema preparsed. This can then be used to parse and produce JSON.
diff --git a/nano/node/ipc/ipc_access_config.cpp b/nano/node/ipc/ipc_access_config.cpp
index 97fabbc897..6b53173e80 100644
--- a/nano/node/ipc/ipc_access_config.cpp
+++ b/nano/node/ipc/ipc_access_config.cpp
@@ -98,7 +98,7 @@ nano::error nano::ipc::access::deserialize_toml (nano::tomlconfig & toml)
 	nano::error error;
 	if (toml.has_key ("role"))
 	{
-		auto get_role = [this](std::shared_ptr<cpptoml::table> const & role_a) {
+		auto get_role = [this] (std::shared_ptr<cpptoml::table> const & role_a) {
 			nano::ipc::access_role role;
 			std::string id_l (role_a->get_as<std::string> ("id").value_or (""));
 			role.id = id_l;
@@ -136,7 +136,7 @@ nano::error nano::ipc::access::deserialize_toml (nano::tomlconfig & toml)
 
 	if (!error && toml.has_key ("user"))
 	{
-		auto get_user = [this, &error](std::shared_ptr<cpptoml::table> const & user_a) {
+		auto get_user = [this, &error] (std::shared_ptr<cpptoml::table> const & user_a) {
 			nano::ipc::access_user user;
 			user.id = user_a->get_as<std::string> ("id").value_or ("");
 			// Check bare flag. The tomlconfig parser stringifies values, so we must retrieve as string.
diff --git a/nano/node/ipc/ipc_broker.cpp b/nano/node/ipc/ipc_broker.cpp
index 628b820f20..b3af919fdc 100644
--- a/nano/node/ipc/ipc_broker.cpp
+++ b/nano/node/ipc/ipc_broker.cpp
@@ -7,7 +7,7 @@
 #include <nano/node/node.hpp>
 
 nano::ipc::broker::broker (nano::node & node_a) :
-node (node_a)
+	node (node_a)
 {
 }
 
@@ -22,7 +22,7 @@ std::shared_ptr<flatbuffers::Parser> nano::ipc::subscriber::get_parser (nano::ip
 
 void nano::ipc::broker::start ()
 {
-	node.observers.blocks.add ([this_l = shared_from_this ()](nano::election_status const & status_a, std::vector<nano::vote_with_weight_info> const & votes_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a) {
+	node.observers.blocks.add ([this_l = shared_from_this ()] (nano::election_status const & status_a, std::vector<nano::vote_with_weight_info> const & votes_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a) {
 		debug_assert (status_a.type != nano::election_status_type::ongoing);
 
 		try
@@ -75,26 +75,26 @@ void subscribe_or_unsubscribe (nano::logger_mt & logger, COLL & subscriber_colle
 {
 	// Evict subscribers from dead sessions. Also remove current subscriber if unsubscribing.
 	subscriber_collection.erase (std::remove_if (subscriber_collection.begin (), subscriber_collection.end (),
-	                             [& logger = logger, topic_a, subscriber_a](auto & sub) {
-		                             bool remove = false;
-		                             auto subscriber_l = sub.subscriber.lock ();
-		                             if (subscriber_l)
-		                             {
-			                             if (auto calling_subscriber_l = subscriber_a.lock ())
-			                             {
-				                             remove = topic_a->unsubscribe && subscriber_l->get_id () == calling_subscriber_l->get_id ();
-				                             if (remove)
-				                             {
-					                             logger.always_log ("IPC: unsubscription from subscriber #", calling_subscriber_l->get_id ());
-				                             }
-			                             }
-		                             }
-		                             else
-		                             {
-			                             remove = true;
-		                             }
-		                             return remove;
-	                             }),
+								 [&logger = logger, topic_a, subscriber_a] (auto & sub) {
+									 bool remove = false;
+									 auto subscriber_l = sub.subscriber.lock ();
+									 if (subscriber_l)
+									 {
+										 if (auto calling_subscriber_l = subscriber_a.lock ())
+										 {
+											 remove = topic_a->unsubscribe && subscriber_l->get_id () == calling_subscriber_l->get_id ();
+											 if (remove)
+											 {
+												 logger.always_log ("IPC: unsubscription from subscriber #", calling_subscriber_l->get_id ());
+											 }
+										 }
+									 }
+									 else
+									 {
+										 remove = true;
+									 }
+									 return remove;
+								 }),
 	subscriber_collection.end ());
 
 	if (!topic_a->unsubscribe)
@@ -119,7 +119,7 @@ void nano::ipc::broker::broadcast (std::shared_ptr<nanoapi::EventConfirmationT>
 	{
 		if (auto subscriber_l = itr->subscriber.lock ())
 		{
-			auto should_filter = [this, &itr, confirmation_a]() {
+			auto should_filter = [this, &itr, confirmation_a] () {
 				debug_assert (itr->topic->options != nullptr);
 				auto conf_filter (itr->topic->options->confirmation_type_filter);
 
@@ -194,11 +194,11 @@ void nano::ipc::broker::broadcast (std::shared_ptr<nanoapi::EventConfirmationT>
 						throw nano::error ("Couldn't serialize response to JSON");
 					}
 
-					subscriber_l->async_send_message (reinterpret_cast<uint8_t const *> (json->data ()), json->size (), [json](const nano::error & err) {});
+					subscriber_l->async_send_message (reinterpret_cast<uint8_t const *> (json->data ()), json->size (), [json] (const nano::error & err) {});
 				}
 				else
 				{
-					subscriber_l->async_send_message (fb->GetBufferPointer (), fb->GetSize (), [fb](const nano::error & err) {});
+					subscriber_l->async_send_message (fb->GetBufferPointer (), fb->GetSize (), [fb] (const nano::error & err) {});
 				}
 			}
 
@@ -245,7 +245,7 @@ void nano::ipc::broker::service_stop (std::string const & service_name_a)
 			{
 				nanoapi::EventServiceStopT event_stop;
 				auto fb (nano::ipc::flatbuffer_producer::make_buffer (event_stop));
-				subscriber_l->async_send_message (fb->GetBufferPointer (), fb->GetSize (), [fb](const nano::error & err) {});
+				subscriber_l->async_send_message (fb->GetBufferPointer (), fb->GetSize (), [fb] (const nano::error & err) {});
 
 				break;
 			}
diff --git a/nano/node/ipc/ipc_broker.hpp b/nano/node/ipc/ipc_broker.hpp
index 5a8dc37a8c..df3d1eb04c 100644
--- a/nano/node/ipc/ipc_broker.hpp
+++ b/nano/node/ipc/ipc_broker.hpp
@@ -35,7 +35,7 @@ namespace ipc
 		 * @param length_a Length of payload message in bytes
 		 * @param broadcast_completion_handler_a Called once sending is completed
 		 */
-		virtual void async_send_message (uint8_t const * data_a, size_t length_a, std::function<void(nano::error const &)> broadcast_completion_handler_a) = 0;
+		virtual void async_send_message (uint8_t const * data_a, size_t length_a, std::function<void (nano::error const &)> broadcast_completion_handler_a) = 0;
 		/** Returns the unique id of the associated session */
 		virtual uint64_t get_id () const = 0;
 		/** Returns the service name associated with the session */
@@ -62,7 +62,7 @@ namespace ipc
 	{
 	public:
 		subscription (std::weak_ptr<nano::ipc::subscriber> const & subscriber_a, std::shared_ptr<TopicType> const & topic_a) :
-		subscriber (subscriber_a), topic (topic_a)
+			subscriber (subscriber_a), topic (topic_a)
 		{
 		}
 
diff --git a/nano/node/ipc/ipc_config.hpp b/nano/node/ipc/ipc_config.hpp
index a09b3b051d..ad7d4b4ee4 100644
--- a/nano/node/ipc/ipc_config.hpp
+++ b/nano/node/ipc/ipc_config.hpp
@@ -53,7 +53,7 @@ namespace ipc
 	{
 	public:
 		ipc_config_tcp_socket () :
-		port (network_constants.default_ipc_port)
+			port (network_constants.default_ipc_port)
 		{
 		}
 		nano::network_constants network_constants;
diff --git a/nano/node/ipc/ipc_server.cpp b/nano/node/ipc/ipc_server.cpp
index c0869f5e90..b6544aae73 100644
--- a/nano/node/ipc/ipc_server.cpp
+++ b/nano/node/ipc/ipc_server.cpp
@@ -37,9 +37,9 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 {
 public:
 	session (nano::ipc::ipc_server & server_a, boost::asio::io_context & io_ctx_a, nano::ipc::ipc_config_transport & config_transport_a) :
-	socket_base (io_ctx_a),
-	server (server_a), node (server_a.node), session_id (server_a.id_dispenser.fetch_add (1)),
-	io_ctx (io_ctx_a), strand (io_ctx_a.get_executor ()), socket (io_ctx_a), config_transport (config_transport_a)
+		socket_base (io_ctx_a),
+		server (server_a), node (server_a.node), session_id (server_a.id_dispenser.fetch_add (1)),
+		io_ctx (io_ctx_a), strand (io_ctx_a.get_executor ()), socket (io_ctx_a), config_transport (config_transport_a)
 	{
 		if (node.config.logging.log_ipc ())
 		{
@@ -63,10 +63,10 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 		{
 		public:
 			subscriber_impl (std::shared_ptr<session> const & session_a) :
-			session_m (session_a)
+				session_m (session_a)
 			{
 			}
-			virtual void async_send_message (uint8_t const * data_a, size_t length_a, std::function<void(nano::error const &)> broadcast_completion_handler_a) override
+			virtual void async_send_message (uint8_t const * data_a, size_t length_a, std::function<void (nano::error const &)> broadcast_completion_handler_a) override
 			{
 				if (auto session_l = session_m.lock ())
 				{
@@ -76,7 +76,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 						boost::asio::buffer (data_a, length_a)
 					};
 
-					session_l->queued_write (buffers, [broadcast_completion_handler_a, big_endian_length](boost::system::error_code const & ec_a, size_t size_a) {
+					session_l->queued_write (buffers, [broadcast_completion_handler_a, big_endian_length] (boost::system::error_code const & ec_a, size_t size_a) {
 						if (broadcast_completion_handler_a)
 						{
 							nano::error error_l (ec_a);
@@ -140,10 +140,10 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 
 	/** Write a fixed array of buffers through the queue. Once the last item is completed, the callback is invoked */
 	template <std::size_t N>
-	void queued_write (boost::array<boost::asio::const_buffer, N> & buffers, std::function<void(boost::system::error_code const &, size_t)> callback_a)
+	void queued_write (boost::array<boost::asio::const_buffer, N> & buffers, std::function<void (boost::system::error_code const &, size_t)> callback_a)
 	{
 		auto this_l (this->shared_from_this ());
-		boost::asio::post (strand, boost::asio::bind_executor (strand, [buffers, callback_a, this_l]() {
+		boost::asio::post (strand, boost::asio::bind_executor (strand, [buffers, callback_a, this_l] () {
 			bool write_in_progress = !this_l->send_queue.empty ();
 			auto queue_size = this_l->send_queue.size ();
 			if (queue_size < this_l->queue_size_max)
@@ -167,10 +167,10 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 	 * @note This function explicitely doesn't use nano::shared_const_buffer, as buffers usually originate from Flatbuffers
 	 * and copying into the shared_const_buffer vector would impose a significant overhead for large requests and responses.
 	 */
-	void queued_write (boost::asio::const_buffer const & buffer_a, std::function<void(boost::system::error_code const &, size_t)> callback_a)
+	void queued_write (boost::asio::const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, size_t)> callback_a)
 	{
 		auto this_l (this->shared_from_this ());
-		boost::asio::post (strand, boost::asio::bind_executor (strand, [buffer_a, callback_a, this_l]() {
+		boost::asio::post (strand, boost::asio::bind_executor (strand, [buffer_a, callback_a, this_l] () {
 			bool write_in_progress = !this_l->send_queue.empty ();
 			auto queue_size = this_l->send_queue.size ();
 			if (queue_size < this_l->queue_size_max)
@@ -191,7 +191,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 		timer_start (std::chrono::seconds (config_transport.io_timeout));
 		nano::unsafe_async_write (socket, msg.buffer,
 		boost::asio::bind_executor (strand,
-		[msg, this_w](boost::system::error_code ec, std::size_t size_a) {
+		[msg, this_w] (boost::system::error_code ec, std::size_t size_a) {
 			if (auto this_l = this_w.lock ())
 			{
 				this_l->timer_cancel ();
@@ -215,7 +215,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 	 * no error has occurred. On error, the error is logged, the read cycle stops and the session ends. Clients
 	 * are expected to implement reconnect logic.
 	 */
-	void async_read_exactly (void * buff_a, size_t size_a, std::function<void()> const & callback_a)
+	void async_read_exactly (void * buff_a, size_t size_a, std::function<void ()> const & callback_a)
 	{
 		async_read_exactly (buff_a, size_a, std::chrono::seconds (config_transport.io_timeout), callback_a);
 	}
@@ -224,7 +224,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 	 * Async read of exactly \p size_a bytes and a specific \p timeout_a.
 	 * @see async_read_exactly (void *, size_t, std::function<void()>)
 	 */
-	void async_read_exactly (void * buff_a, size_t size_a, std::chrono::seconds timeout_a, std::function<void()> const & callback_a)
+	void async_read_exactly (void * buff_a, size_t size_a, std::chrono::seconds timeout_a, std::function<void ()> const & callback_a)
 	{
 		timer_start (timeout_a);
 		auto this_l (this->shared_from_this ());
@@ -232,7 +232,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 		boost::asio::buffer (buff_a, size_a),
 		boost::asio::transfer_exactly (size_a),
 		boost::asio::bind_executor (strand,
-		[this_l, callback_a](boost::system::error_code const & ec, size_t bytes_transferred_a) {
+		[this_l, callback_a] (boost::system::error_code const & ec, size_t bytes_transferred_a) {
 			this_l->timer_cancel ();
 			if (ec == boost::asio::error::broken_pipe || ec == boost::asio::error::connection_aborted || ec == boost::asio::error::connection_reset || ec == boost::asio::error::connection_refused)
 			{
@@ -257,7 +257,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 		// This is called when nano::rpc_handler#process_request is done. We convert to
 		// json and write the response to the ipc socket with a length prefix.
 		auto this_l (this->shared_from_this ());
-		auto response_handler_l ([this_l, request_id_l](std::string const & body) {
+		auto response_handler_l ([this_l, request_id_l] (std::string const & body) {
 			auto big = boost::endian::native_to_big (static_cast<uint32_t> (body.size ()));
 			auto buffer (std::make_shared<std::vector<uint8_t>> ());
 			buffer->insert (buffer->end (), reinterpret_cast<std::uint8_t *> (&big), reinterpret_cast<std::uint8_t *> (&big) + sizeof (std::uint32_t));
@@ -268,7 +268,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 			}
 
 			this_l->timer_start (std::chrono::seconds (this_l->config_transport.io_timeout));
-			this_l->queued_write (boost::asio::buffer (buffer->data (), buffer->size ()), [this_l, buffer](boost::system::error_code const & error_a, size_t size_a) {
+			this_l->queued_write (boost::asio::buffer (buffer->data (), buffer->size ()), [this_l, buffer] (boost::system::error_code const & error_a, size_t size_a) {
 				this_l->timer_cancel ();
 				if (!error_a)
 				{
@@ -287,9 +287,9 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 		auto body (std::string (reinterpret_cast<char *> (buffer.data ()), buffer.size ()));
 
 		// Note that if the rpc action is async, the shared_ptr<json_handler> lifetime will be extended by the action handler
-		auto handler (std::make_shared<nano::json_handler> (node, server.node_rpc_config, body, response_handler_l, [& server = server]() {
+		auto handler (std::make_shared<nano::json_handler> (node, server.node_rpc_config, body, response_handler_l, [&server = server] () {
 			server.stop ();
-			server.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (3), [& io_ctx = server.node.io_ctx]() {
+			server.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (3), [&io_ctx = server.node.io_ctx] () {
 				io_ctx.stop ();
 			});
 		}));
@@ -304,7 +304,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 
 		// Await next request indefinitely
 		buffer.resize (sizeof (buffer_size));
-		async_read_exactly (buffer.data (), buffer.size (), std::chrono::seconds::max (), [this_l]() {
+		async_read_exactly (buffer.data (), buffer.size (), std::chrono::seconds::max (), [this_l] () {
 			auto encoding (this_l->buffer[nano::ipc::preamble_offset::encoding]);
 			this_l->active_encoding = static_cast<nano::ipc::payload_encoding> (encoding);
 			if (this_l->buffer[nano::ipc::preamble_offset::lead] != 'N' || this_l->buffer[nano::ipc::preamble_offset::reserved_1] != 0 || this_l->buffer[nano::ipc::preamble_offset::reserved_2] != 0)
@@ -318,11 +318,11 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 			{
 				auto allow_unsafe (encoding == static_cast<uint8_t> (nano::ipc::payload_encoding::json_v1_unsafe));
 				// Length of payload
-				this_l->async_read_exactly (&this_l->buffer_size, sizeof (this_l->buffer_size), [this_l, allow_unsafe]() {
+				this_l->async_read_exactly (&this_l->buffer_size, sizeof (this_l->buffer_size), [this_l, allow_unsafe] () {
 					boost::endian::big_to_native_inplace (this_l->buffer_size);
 					this_l->buffer.resize (this_l->buffer_size);
 					// Payload (ptree compliant JSON string)
-					this_l->async_read_exactly (this_l->buffer.data (), this_l->buffer_size, [this_l, allow_unsafe]() {
+					this_l->async_read_exactly (this_l->buffer.data (), this_l->buffer_size, [this_l, allow_unsafe] () {
 						this_l->handle_json_query (allow_unsafe);
 					});
 				});
@@ -330,11 +330,11 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 			else if (encoding == static_cast<uint8_t> (nano::ipc::payload_encoding::flatbuffers) || encoding == static_cast<uint8_t> (nano::ipc::payload_encoding::flatbuffers_json))
 			{
 				// Length of payload
-				this_l->async_read_exactly (&this_l->buffer_size, sizeof (this_l->buffer_size), [this_l, encoding]() {
+				this_l->async_read_exactly (&this_l->buffer_size, sizeof (this_l->buffer_size), [this_l, encoding] () {
 					boost::endian::big_to_native_inplace (this_l->buffer_size);
 					this_l->buffer.resize (this_l->buffer_size);
 					// Payload (flatbuffers or flatbuffers mappable json)
-					this_l->async_read_exactly (this_l->buffer.data (), this_l->buffer_size, [this_l, encoding]() {
+					this_l->async_read_exactly (this_l->buffer.data (), this_l->buffer_size, [this_l, encoding] () {
 						this_l->session_timer.restart ();
 
 						// Lazily create one Flatbuffers handler instance per session
@@ -345,7 +345,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 
 						if (encoding == static_cast<uint8_t> (nano::ipc::payload_encoding::flatbuffers_json))
 						{
-							this_l->flatbuffers_handler->process_json (this_l->buffer.data (), this_l->buffer_size, [this_l](std::shared_ptr<std::string> const & body) {
+							this_l->flatbuffers_handler->process_json (this_l->buffer.data (), this_l->buffer_size, [this_l] (std::shared_ptr<std::string> const & body) {
 								if (this_l->node.config.logging.log_ipc ())
 								{
 									this_l->node.logger.always_log (boost::str (boost::format ("IPC/Flatbuffer request completed in: %1% %2%") % this_l->session_timer.stop ().count () % this_l->session_timer.unit ()));
@@ -357,7 +357,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 									boost::asio::buffer (body->data (), body->size ())
 								};
 
-								this_l->queued_write (buffers, [this_l, body, big_endian_length](boost::system::error_code const & error_a, size_t size_a) {
+								this_l->queued_write (buffers, [this_l, body, big_endian_length] (boost::system::error_code const & error_a, size_t size_a) {
 									if (!error_a)
 									{
 										this_l->read_next_request ();
@@ -371,7 +371,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 						}
 						else
 						{
-							this_l->flatbuffers_handler->process (this_l->buffer.data (), this_l->buffer_size, [this_l](std::shared_ptr<flatbuffers::FlatBufferBuilder> const & fbb) {
+							this_l->flatbuffers_handler->process (this_l->buffer.data (), this_l->buffer_size, [this_l] (std::shared_ptr<flatbuffers::FlatBufferBuilder> const & fbb) {
 								if (this_l->node.config.logging.log_ipc ())
 								{
 									this_l->node.logger.always_log (boost::str (boost::format ("IPC/Flatbuffer request completed in: %1% %2%") % this_l->session_timer.stop ().count () % this_l->session_timer.unit ()));
@@ -383,7 +383,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 									boost::asio::buffer (fbb->GetBufferPointer (), fbb->GetSize ())
 								};
 
-								this_l->queued_write (buffers, [this_l, fbb, big_endian_length](boost::system::error_code const & error_a, size_t size_a) {
+								this_l->queued_write (buffers, [this_l, fbb, big_endian_length] (boost::system::error_code const & error_a, size_t size_a) {
 									if (!error_a)
 									{
 										this_l->read_next_request ();
@@ -419,7 +419,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f
 	{
 	public:
 		boost::asio::const_buffer buffer;
-		std::function<void(boost::system::error_code const &, size_t)> callback;
+		std::function<void (boost::system::error_code const &, size_t)> callback;
 	};
 	size_t const queue_size_max = 64 * 1024;
 
@@ -478,7 +478,7 @@ class socket_transport : public nano::ipc::transport
 {
 public:
 	socket_transport (nano::ipc::ipc_server & server_a, ENDPOINT_TYPE endpoint_a, nano::ipc::ipc_config_transport & config_transport_a, int concurrency_a) :
-	server (server_a), config_transport (config_transport_a)
+		server (server_a), config_transport (config_transport_a)
 	{
 		// Using a per-transport event dispatcher?
 		if (concurrency_a > 0)
@@ -511,7 +511,7 @@ class socket_transport : public nano::ipc::transport
 		// Prepare the next session
 		auto new_session (std::make_shared<session<SOCKET_TYPE>> (server, context (), config_transport));
 
-		acceptor->async_accept (new_session->get_socket (), [this, new_session](boost::system::error_code const & ec) {
+		acceptor->async_accept (new_session->get_socket (), [this, new_session] (boost::system::error_code const & ec) {
 			if (!ec)
 			{
 				new_session->read_next_request ();
@@ -561,7 +561,7 @@ class socket_transport : public nano::ipc::transport
  */
 void await_hup_signal (std::shared_ptr<boost::asio::signal_set> const & signals, nano::ipc::ipc_server & server_a)
 {
-	signals->async_wait ([signals, &server_a](const boost::system::error_code & ec, int signal_number) {
+	signals->async_wait ([signals, &server_a] (const boost::system::error_code & ec, int signal_number) {
 		if (ec != boost::asio::error::operation_aborted)
 		{
 			std::cout << "Reloading access configuration..." << std::endl;
@@ -576,9 +576,9 @@ void await_hup_signal (std::shared_ptr<boost::asio::signal_set> const & signals,
 }
 
 nano::ipc::ipc_server::ipc_server (nano::node & node_a, nano::node_rpc_config const & node_rpc_config_a) :
-node (node_a),
-node_rpc_config (node_rpc_config_a),
-broker (std::make_shared<nano::ipc::broker> (node_a))
+	node (node_a),
+	node_rpc_config (node_rpc_config_a),
+	broker (std::make_shared<nano::ipc::broker> (node_a))
 {
 	try
 	{
diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp
index a063ded2af..b76b802001 100644
--- a/nano/node/json_handler.cpp
+++ b/nano/node/json_handler.cpp
@@ -18,25 +18,25 @@
 namespace
 {
 void construct_json (nano::container_info_component * component, boost::property_tree::ptree & parent);
-using ipc_json_handler_no_arg_func_map = std::unordered_map<std::string, std::function<void(nano::json_handler *)>>;
+using ipc_json_handler_no_arg_func_map = std::unordered_map<std::string, std::function<void (nano::json_handler *)>>;
 ipc_json_handler_no_arg_func_map create_ipc_json_handler_no_arg_func_map ();
 auto ipc_json_handler_no_arg_funcs = create_ipc_json_handler_no_arg_func_map ();
 bool block_confirmed (nano::node & node, nano::transaction & transaction, nano::block_hash const & hash, bool include_active, bool include_only_confirmed);
 const char * epoch_as_string (nano::epoch);
 }
 
-nano::json_handler::json_handler (nano::node & node_a, nano::node_rpc_config const & node_rpc_config_a, std::string const & body_a, std::function<void(std::string const &)> const & response_a, std::function<void()> stop_callback_a) :
-body (body_a),
-node (node_a),
-response (response_a),
-stop_callback (stop_callback_a),
-node_rpc_config (node_rpc_config_a)
+nano::json_handler::json_handler (nano::node & node_a, nano::node_rpc_config const & node_rpc_config_a, std::string const & body_a, std::function<void (std::string const &)> const & response_a, std::function<void ()> stop_callback_a) :
+	body (body_a),
+	node (node_a),
+	response (response_a),
+	stop_callback (stop_callback_a),
+	node_rpc_config (node_rpc_config_a)
 {
 }
 
-std::function<void()> nano::json_handler::create_worker_task (std::function<void(std::shared_ptr<nano::json_handler> const &)> const & action_a)
+std::function<void ()> nano::json_handler::create_worker_task (std::function<void (std::shared_ptr<nano::json_handler> const &)> const & action_a)
 {
-	return [rpc_l = shared_from_this (), action_a]() {
+	return [rpc_l = shared_from_this (), action_a] () {
 		try
 		{
 			action_a (rpc_l);
@@ -539,7 +539,7 @@ void nano::json_handler::account_block_count ()
 
 void nano::json_handler::account_create ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		auto wallet (rpc_l->wallet_impl ());
 		if (!rpc_l->ec)
 		{
@@ -726,7 +726,7 @@ void nano::json_handler::account_list ()
 
 void nano::json_handler::account_move ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		auto wallet (rpc_l->wallet_impl ());
 		if (!rpc_l->ec)
 		{
@@ -765,7 +765,7 @@ void nano::json_handler::account_move ()
 
 void nano::json_handler::account_remove ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		auto wallet (rpc_l->wallet_impl ());
 		auto account (rpc_l->account_impl ());
 		if (!rpc_l->ec)
@@ -800,7 +800,7 @@ void nano::json_handler::account_representative ()
 
 void nano::json_handler::account_representative_set ()
 {
-	node.workers.push_task (create_worker_task ([work_generation_enabled = node.work_generation_enabled ()](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([work_generation_enabled = node.work_generation_enabled ()] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		auto wallet (rpc_l->wallet_impl ());
 		auto account (rpc_l->account_impl ());
 		std::string representative_text (rpc_l->request.get<std::string> ("representative"));
@@ -840,7 +840,7 @@ void nano::json_handler::account_representative_set ()
 				auto response_a (rpc_l->response);
 				auto response_data (std::make_shared<boost::property_tree::ptree> (rpc_l->response_l));
 				wallet->change_async (
-				account, representative, [response_a, response_data](std::shared_ptr<nano::block> const & block) {
+				account, representative, [response_a, response_data] (std::shared_ptr<nano::block> const & block) {
 					if (block != nullptr)
 					{
 						response_data->put ("block", block->hash ().to_string ());
@@ -896,7 +896,7 @@ void nano::json_handler::accounts_balances ()
 
 void nano::json_handler::accounts_create ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		auto wallet (rpc_l->wallet_impl ());
 		auto count (rpc_l->count_impl ());
 		if (!rpc_l->ec)
@@ -991,13 +991,13 @@ void nano::json_handler::accounts_pending ()
 			{
 				if (source)
 				{
-					peers_l.sort ([](const auto & child1, const auto & child2) -> bool {
+					peers_l.sort ([] (const auto & child1, const auto & child2) -> bool {
 						return child1.second.template get<nano::uint128_t> ("amount") > child2.second.template get<nano::uint128_t> ("amount");
 					});
 				}
 				else
 				{
-					peers_l.sort ([](const auto & child1, const auto & child2) -> bool {
+					peers_l.sort ([] (const auto & child1, const auto & child2) -> bool {
 						return child1.second.template get<nano::uint128_t> ("") > child2.second.template get<nano::uint128_t> ("");
 					});
 				}
@@ -1462,7 +1462,7 @@ void nano::json_handler::block_create ()
 	{
 		auto rpc_l (shared_from_this ());
 		// Serializes the block contents to the RPC response
-		auto block_response_put_l = [rpc_l, this](nano::block const & block_a) {
+		auto block_response_put_l = [rpc_l, this] (nano::block const & block_a) {
 			boost::property_tree::ptree response_l;
 			response_l.put ("hash", block_a.hash ().to_string ());
 			response_l.put ("difficulty", nano::to_string_hex (block_a.difficulty ()));
@@ -1484,9 +1484,9 @@ void nano::json_handler::block_create ()
 			rpc_l->response (ostream.str ());
 		};
 		// Wrapper from argument to lambda capture, to extend the block's scope
-		auto get_callback_l = [rpc_l, block_response_put_l](std::shared_ptr<nano::block> const & block_a) {
+		auto get_callback_l = [rpc_l, block_response_put_l] (std::shared_ptr<nano::block> const & block_a) {
 			// Callback upon work generation success or failure
-			return [block_a, rpc_l, block_response_put_l](boost::optional<uint64_t> const & work_a) {
+			return [block_a, rpc_l, block_response_put_l] (boost::optional<uint64_t> const & work_a) {
 				if (block_a != nullptr)
 				{
 					if (work_a.is_initialized ())
@@ -1545,13 +1545,13 @@ void nano::json_handler::block_create ()
 				if (previous_text.is_initialized () && !representative.is_zero () && (!link.is_zero () || link_text.is_initialized ()))
 				{
 					block_l = builder_l.state ()
-					          .account (pub)
-					          .previous (previous)
-					          .representative (representative)
-					          .balance (balance)
-					          .link (link)
-					          .sign (prv, pub)
-					          .build (ec_build);
+							  .account (pub)
+							  .previous (previous)
+							  .representative (representative)
+							  .balance (balance)
+							  .link (link)
+							  .sign (prv, pub)
+							  .build (ec_build);
 					if (previous.is_zero ())
 					{
 						root_l = pub;
@@ -1571,11 +1571,11 @@ void nano::json_handler::block_create ()
 				if (representative != 0 && source != 0)
 				{
 					block_l = builder_l.open ()
-					          .account (pub)
-					          .source (source)
-					          .representative (representative)
-					          .sign (prv, pub)
-					          .build (ec_build);
+							  .account (pub)
+							  .source (source)
+							  .representative (representative)
+							  .sign (prv, pub)
+							  .build (ec_build);
 					root_l = pub;
 				}
 				else
@@ -1588,10 +1588,10 @@ void nano::json_handler::block_create ()
 				if (source != 0 && previous != 0)
 				{
 					block_l = builder_l.receive ()
-					          .previous (previous)
-					          .source (source)
-					          .sign (prv, pub)
-					          .build (ec_build);
+							  .previous (previous)
+							  .source (source)
+							  .sign (prv, pub)
+							  .build (ec_build);
 					root_l = previous;
 				}
 				else
@@ -1604,10 +1604,10 @@ void nano::json_handler::block_create ()
 				if (representative != 0 && previous != 0)
 				{
 					block_l = builder_l.change ()
-					          .previous (previous)
-					          .representative (representative)
-					          .sign (prv, pub)
-					          .build (ec_build);
+							  .previous (previous)
+							  .representative (representative)
+							  .sign (prv, pub)
+							  .build (ec_build);
 					root_l = previous;
 				}
 				else
@@ -1622,11 +1622,11 @@ void nano::json_handler::block_create ()
 					if (balance.number () >= amount.number ())
 					{
 						block_l = builder_l.send ()
-						          .previous (previous)
-						          .destination (destination)
-						          .balance (balance.number () - amount.number ())
-						          .sign (prv, pub)
-						          .build (ec_build);
+								  .previous (previous)
+								  .destination (destination)
+								  .balance (balance.number () - amount.number ())
+								  .sign (prv, pub)
+								  .build (ec_build);
 						root_l = previous;
 					}
 					else
@@ -2230,12 +2230,12 @@ class history_visitor : public nano::block_visitor
 {
 public:
 	history_visitor (nano::json_handler & handler_a, bool raw_a, nano::transaction & transaction_a, boost::property_tree::ptree & tree_a, nano::block_hash const & hash_a, std::vector<nano::public_key> const & accounts_filter_a) :
-	handler (handler_a),
-	raw (raw_a),
-	transaction (transaction_a),
-	tree (tree_a),
-	hash (hash_a),
-	accounts_filter (accounts_filter_a)
+		handler (handler_a),
+		raw (raw_a),
+		transaction (transaction_a),
+		tree (tree_a),
+		hash (hash_a),
+		accounts_filter (accounts_filter_a)
 	{
 	}
 	virtual ~history_visitor () = default;
@@ -2760,7 +2760,7 @@ void nano::json_handler::node_id_delete ()
 
 void nano::json_handler::password_change ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		auto wallet (rpc_l->wallet_impl ());
 		if (!rpc_l->ec)
 		{
@@ -2783,7 +2783,7 @@ void nano::json_handler::password_change ()
 
 void nano::json_handler::password_enter ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		auto wallet (rpc_l->wallet_impl ());
 		if (!rpc_l->ec)
 		{
@@ -2820,7 +2820,7 @@ void nano::json_handler::peers ()
 	boost::property_tree::ptree peers_l;
 	const bool peer_details = request.get<bool> ("peer_details", false);
 	auto peers_list (node.network.list (std::numeric_limits<size_t>::max ()));
-	std::sort (peers_list.begin (), peers_list.end (), [](const auto & lhs, const auto & rhs) {
+	std::sort (peers_list.begin (), peers_list.end (), [] (const auto & lhs, const auto & rhs) {
 		return lhs->get_endpoint () < rhs->get_endpoint ();
 	});
 	for (auto i (peers_list.begin ()), n (peers_list.end ()); i != n; ++i)
@@ -2930,7 +2930,7 @@ void nano::json_handler::pending ()
 			if (source || min_version)
 			{
 				auto mid = hash_ptree_pairs.size () <= count ? hash_ptree_pairs.end () : hash_ptree_pairs.begin () + count;
-				std::partial_sort (hash_ptree_pairs.begin (), mid, hash_ptree_pairs.end (), [](const auto & lhs, const auto & rhs) {
+				std::partial_sort (hash_ptree_pairs.begin (), mid, hash_ptree_pairs.end (), [] (const auto & lhs, const auto & rhs) {
 					return lhs.second.template get<nano::uint128_t> ("amount") > rhs.second.template get<nano::uint128_t> ("amount");
 				});
 				for (auto i = 0; i < hash_ptree_pairs.size () && i < count; ++i)
@@ -2941,7 +2941,7 @@ void nano::json_handler::pending ()
 			else
 			{
 				auto mid = hash_amount_pairs.size () <= count ? hash_amount_pairs.end () : hash_amount_pairs.begin () + count;
-				std::partial_sort (hash_amount_pairs.begin (), mid, hash_amount_pairs.end (), [](const auto & lhs, const auto & rhs) {
+				std::partial_sort (hash_amount_pairs.begin (), mid, hash_amount_pairs.end (), [] (const auto & lhs, const auto & rhs) {
 					return lhs.second > rhs.second;
 				});
 
@@ -2986,7 +2986,7 @@ void nano::json_handler::pending_exists ()
 
 void nano::json_handler::process ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		const bool watch_work_l = rpc_l->request.get<bool> ("watch_work", true);
 		const bool is_async = rpc_l->request.get<bool> ("async", false);
 		auto block (rpc_l->block_impl (true));
@@ -3241,7 +3241,7 @@ void nano::json_handler::receive ()
 						bool generate_work (work == 0); // Disable work generation if "work" option is provided
 						auto response_a (response);
 						wallet->receive_async (
-						hash, representative, node.network_params.ledger.genesis_amount, account, [response_a](std::shared_ptr<nano::block> const & block_a) {
+						hash, representative, node.network_params.ledger.genesis_amount, account, [response_a] (std::shared_ptr<nano::block> const & block_a) {
 							if (block_a != nullptr)
 							{
 								boost::property_tree::ptree response_l;
@@ -3578,7 +3578,7 @@ void nano::json_handler::send ()
 			auto response_a (response);
 			auto response_data (std::make_shared<boost::property_tree::ptree> (response_l));
 			wallet->send_async (
-			source, destination, amount.number (), [balance, amount, response_a, response_data](std::shared_ptr<nano::block> const & block_a) {
+			source, destination, amount.number (), [balance, amount, response_a, response_data] (std::shared_ptr<nano::block> const & block_a) {
 				if (block_a != nullptr)
 				{
 					response_data->put ("block", block_a->hash ().to_string ());
@@ -3834,7 +3834,7 @@ void nano::json_handler::telemetry ()
 			debug_assert (channel);
 			if (node.telemetry)
 			{
-				node.telemetry->get_metrics_single_peer_async (channel, [rpc_l](auto const & telemetry_response_a) {
+				node.telemetry->get_metrics_single_peer_async (channel, [rpc_l] (auto const & telemetry_response_a) {
 					if (!telemetry_response_a.error)
 					{
 						nano::jsonconfig config_l;
@@ -3905,7 +3905,7 @@ void nano::json_handler::telemetry ()
 				nano::jsonconfig config_l;
 				std::vector<nano::telemetry_data> telemetry_datas;
 				telemetry_datas.reserve (telemetry_responses.size ());
-				std::transform (telemetry_responses.begin (), telemetry_responses.end (), std::back_inserter (telemetry_datas), [](auto const & endpoint_telemetry_data) {
+				std::transform (telemetry_responses.begin (), telemetry_responses.end (), std::back_inserter (telemetry_datas), [] (auto const & endpoint_telemetry_data) {
 					return endpoint_telemetry_data.second;
 				});
 
@@ -3961,7 +3961,7 @@ void nano::json_handler::unchecked ()
 
 void nano::json_handler::unchecked_clear ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		auto transaction (rpc_l->node.store.tx_begin_write ({ tables::unchecked }));
 		rpc_l->node.store.unchecked_clear (transaction);
 		rpc_l->response_l.put ("success", "");
@@ -4140,7 +4140,7 @@ void nano::json_handler::validate_account_number ()
 
 void nano::json_handler::wallet_add ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		auto wallet (rpc_l->wallet_impl ());
 		if (!rpc_l->ec)
 		{
@@ -4170,7 +4170,7 @@ void nano::json_handler::wallet_add ()
 
 void nano::json_handler::wallet_add_watch ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		auto wallet (rpc_l->wallet_impl ());
 		if (!rpc_l->ec)
 		{
@@ -4270,7 +4270,7 @@ void nano::json_handler::wallet_balances ()
 
 void nano::json_handler::wallet_change_seed ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		auto wallet (rpc_l->wallet_impl ());
 		if (!rpc_l->ec)
 		{
@@ -4318,7 +4318,7 @@ void nano::json_handler::wallet_contains ()
 
 void nano::json_handler::wallet_create ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		nano::raw_key seed;
 		auto seed_text (rpc_l->request.get_optional<std::string> ("seed"));
 		if (seed_text.is_initialized () && seed.decode_hex (seed_text.get ()))
@@ -4354,7 +4354,7 @@ void nano::json_handler::wallet_create ()
 
 void nano::json_handler::wallet_destroy ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		std::string wallet_text (rpc_l->request.get<std::string> ("wallet"));
 		nano::wallet_id wallet;
 		if (!wallet.decode_hex (wallet_text))
@@ -4637,7 +4637,7 @@ void nano::json_handler::wallet_representative ()
 
 void nano::json_handler::wallet_representative_set ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		auto wallet (rpc_l->wallet_impl ());
 		std::string representative_text (rpc_l->request.get<std::string> ("representative"));
 		auto representative (rpc_l->account_impl (representative_text, nano::error_rpc::bad_representative_number));
@@ -4679,7 +4679,7 @@ void nano::json_handler::wallet_representative_set ()
 				for (auto & account : accounts)
 				{
 					wallet->change_async (
-					account, representative, [](std::shared_ptr<nano::block> const &) {}, 0, false);
+					account, representative, [] (std::shared_ptr<nano::block> const &) {}, 0, false);
 				}
 			}
 		}
@@ -4826,7 +4826,7 @@ void nano::json_handler::work_generate ()
 		{
 			auto use_peers (request.get<bool> ("use_peers", false));
 			auto rpc_l (shared_from_this ());
-			auto callback = [rpc_l, hash, work_version, this](boost::optional<uint64_t> const & work_a) {
+			auto callback = [rpc_l, hash, work_version, this] (boost::optional<uint64_t> const & work_a) {
 				if (work_a)
 				{
 					boost::property_tree::ptree response_l;
@@ -4924,7 +4924,7 @@ void nano::json_handler::work_get ()
 
 void nano::json_handler::work_set ()
 {
-	node.workers.push_task (create_worker_task ([](std::shared_ptr<nano::json_handler> const & rpc_l) {
+	node.workers.push_task (create_worker_task ([] (std::shared_ptr<nano::json_handler> const & rpc_l) {
 		auto wallet (rpc_l->wallet_impl ());
 		auto account (rpc_l->account_impl ());
 		auto work (rpc_l->work_optional_impl ());
@@ -5011,17 +5011,17 @@ void nano::json_handler::work_peers_clear ()
 	response_errors ();
 }
 
-void nano::inprocess_rpc_handler::process_request (std::string const &, std::string const & body_a, std::function<void(std::string const &)> response_a)
+void nano::inprocess_rpc_handler::process_request (std::string const &, std::string const & body_a, std::function<void (std::string const &)> response_a)
 {
 	// Note that if the rpc action is async, the shared_ptr<json_handler> lifetime will be extended by the action handler
-	auto handler (std::make_shared<nano::json_handler> (node, node_rpc_config, body_a, response_a, [this]() {
+	auto handler (std::make_shared<nano::json_handler> (node, node_rpc_config, body_a, response_a, [this] () {
 		this->stop_callback ();
 		this->stop ();
 	}));
 	handler->process_request ();
 }
 
-void nano::inprocess_rpc_handler::process_request_v2 (rpc_handler_request_params const & params_a, std::string const & body_a, std::function<void(std::shared_ptr<std::string> const &)> response_a)
+void nano::inprocess_rpc_handler::process_request_v2 (rpc_handler_request_params const & params_a, std::string const & body_a, std::function<void (std::shared_ptr<std::string> const &)> response_a)
 {
 	std::string body_l = params_a.json_envelope (body_a);
 	auto handler (std::make_shared<nano::ipc::flatbuffers_handler> (node, ipc_server, nullptr, node.config.ipc_config));
diff --git a/nano/node/json_handler.hpp b/nano/node/json_handler.hpp
index b98fa215f0..67c6380110 100644
--- a/nano/node/json_handler.hpp
+++ b/nano/node/json_handler.hpp
@@ -23,7 +23,7 @@ class json_handler : public std::enable_shared_from_this<nano::json_handler>
 {
 public:
 	json_handler (
-	nano::node &, nano::node_rpc_config const &, std::string const &, std::function<void(std::string const &)> const &, std::function<void()> stop_callback = []() {});
+	nano::node &, nano::node_rpc_config const &, std::string const &, std::function<void (std::string const &)> const &, std::function<void ()> stop_callback = [] () {});
 	void process_request (bool unsafe = false);
 	void account_balance ();
 	void account_block_count ();
@@ -138,7 +138,7 @@ class json_handler : public std::enable_shared_from_this<nano::json_handler>
 	std::string body;
 	nano::node & node;
 	boost::property_tree::ptree request;
-	std::function<void(std::string const &)> response;
+	std::function<void (std::string const &)> response;
 	void response_errors ();
 	std::error_code ec;
 	std::string action;
@@ -161,25 +161,25 @@ class json_handler : public std::enable_shared_from_this<nano::json_handler>
 	double multiplier_optional_impl (nano::work_version const, uint64_t &);
 	nano::work_version work_version_optional_impl (nano::work_version const default_a);
 	bool enable_sign_hash{ false };
-	std::function<void()> stop_callback;
+	std::function<void ()> stop_callback;
 	nano::node_rpc_config const & node_rpc_config;
-	std::function<void()> create_worker_task (std::function<void(std::shared_ptr<nano::json_handler> const &)> const &);
+	std::function<void ()> create_worker_task (std::function<void (std::shared_ptr<nano::json_handler> const &)> const &);
 };
 
 class inprocess_rpc_handler final : public nano::rpc_handler_interface
 {
 public:
 	inprocess_rpc_handler (
-	nano::node & node_a, nano::ipc::ipc_server & ipc_server_a, nano::node_rpc_config const & node_rpc_config_a, std::function<void()> stop_callback_a = []() {}) :
-	node (node_a),
-	ipc_server (ipc_server_a),
-	stop_callback (stop_callback_a),
-	node_rpc_config (node_rpc_config_a)
+	nano::node & node_a, nano::ipc::ipc_server & ipc_server_a, nano::node_rpc_config const & node_rpc_config_a, std::function<void ()> stop_callback_a = [] () {}) :
+		node (node_a),
+		ipc_server (ipc_server_a),
+		stop_callback (stop_callback_a),
+		node_rpc_config (node_rpc_config_a)
 	{
 	}
 
-	void process_request (std::string const &, std::string const & body_a, std::function<void(std::string const &)> response_a) override;
-	void process_request_v2 (rpc_handler_request_params const & params_a, std::string const & body_a, std::function<void(std::shared_ptr<std::string> const &)> response_a) override;
+	void process_request (std::string const &, std::string const & body_a, std::function<void (std::string const &)> response_a) override;
+	void process_request_v2 (rpc_handler_request_params const & params_a, std::string const & body_a, std::function<void (std::shared_ptr<std::string> const &)> response_a) override;
 
 	void stop () override
 	{
@@ -198,7 +198,7 @@ class inprocess_rpc_handler final : public nano::rpc_handler_interface
 	nano::node & node;
 	nano::ipc::ipc_server & ipc_server;
 	boost::optional<nano::rpc &> rpc;
-	std::function<void()> stop_callback;
+	std::function<void ()> stop_callback;
 	nano::node_rpc_config const & node_rpc_config;
 };
 }
diff --git a/nano/node/lmdb/lmdb.cpp b/nano/node/lmdb/lmdb.cpp
index 883249fd1e..cbb117fc5b 100644
--- a/nano/node/lmdb/lmdb.cpp
+++ b/nano/node/lmdb/lmdb.cpp
@@ -29,7 +29,7 @@ size_t mdb_val::size () const
 
 template <>
 mdb_val::db_val (size_t size_a, void * data_a) :
-value ({ size_a, data_a })
+	value ({ size_a, data_a })
 {
 }
 
@@ -41,10 +41,10 @@ void mdb_val::convert_buffer_to_value ()
 }
 
 nano::mdb_store::mdb_store (nano::logger_mt & logger_a, boost::filesystem::path const & path_a, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, nano::lmdb_config const & lmdb_config_a, bool backup_before_upgrade_a) :
-logger (logger_a),
-env (error, path_a, nano::mdb_env::options::make ().set_config (lmdb_config_a).set_use_no_mem_init (true)),
-mdb_txn_tracker (logger_a, txn_tracking_config_a, block_processor_batch_max_time_a),
-txn_tracking_enabled (txn_tracking_config_a.enable)
+	logger (logger_a),
+	env (error, path_a, nano::mdb_env::options::make ().set_config (lmdb_config_a).set_use_no_mem_init (true)),
+	mdb_txn_tracker (logger_a, txn_tracking_config_a, block_processor_batch_max_time_a),
+	txn_tracking_enabled (txn_tracking_config_a.enable)
 {
 	if (!error)
 	{
@@ -121,8 +121,8 @@ bool nano::mdb_store::vacuum_after_upgrade (boost::filesystem::path const & path
 
 		// Set up the environment again
 		auto options = nano::mdb_env::options::make ()
-		               .set_config (lmdb_config_a)
-		               .set_use_no_mem_init (true);
+					   .set_config (lmdb_config_a)
+					   .set_use_no_mem_init (true);
 		env.init (error, path_a, options);
 		if (!error)
 		{
@@ -176,10 +176,10 @@ nano::mdb_txn_callbacks nano::mdb_store::create_txn_callbacks () const
 	nano::mdb_txn_callbacks mdb_txn_callbacks;
 	if (txn_tracking_enabled)
 	{
-		mdb_txn_callbacks.txn_start = ([& mdb_txn_tracker = mdb_txn_tracker](const nano::transaction_impl * transaction_impl) {
+		mdb_txn_callbacks.txn_start = ([&mdb_txn_tracker = mdb_txn_tracker] (const nano::transaction_impl * transaction_impl) {
 			mdb_txn_tracker.add (transaction_impl);
 		});
-		mdb_txn_callbacks.txn_end = ([& mdb_txn_tracker = mdb_txn_tracker](const nano::transaction_impl * transaction_impl) {
+		mdb_txn_callbacks.txn_end = ([&mdb_txn_tracker = mdb_txn_tracker] (const nano::transaction_impl * transaction_impl) {
 			mdb_txn_tracker.erase (transaction_impl);
 		});
 	}
@@ -1181,8 +1181,8 @@ std::shared_ptr<nano::block> nano::mdb_store::block_get_v14 (nano::transaction c
 }
 
 nano::mdb_store::upgrade_counters::upgrade_counters (uint64_t count_before_v0, uint64_t count_before_v1) :
-before_v0 (count_before_v0),
-before_v1 (count_before_v1)
+	before_v0 (count_before_v0),
+	before_v1 (count_before_v1)
 {
 }
 
diff --git a/nano/node/lmdb/lmdb_iterator.hpp b/nano/node/lmdb/lmdb_iterator.hpp
index e4401539fc..4968d7f2a6 100644
--- a/nano/node/lmdb/lmdb_iterator.hpp
+++ b/nano/node/lmdb/lmdb_iterator.hpp
@@ -168,20 +168,20 @@ class mdb_merge_iterator : public store_iterator_impl<T, U>
 {
 public:
 	mdb_merge_iterator (nano::transaction const & transaction_a, MDB_dbi db1_a, MDB_dbi db2_a) :
-	impl1 (std::make_unique<nano::mdb_iterator<T, U>> (transaction_a, db1_a)),
-	impl2 (std::make_unique<nano::mdb_iterator<T, U>> (transaction_a, db2_a))
+		impl1 (std::make_unique<nano::mdb_iterator<T, U>> (transaction_a, db1_a)),
+		impl2 (std::make_unique<nano::mdb_iterator<T, U>> (transaction_a, db2_a))
 	{
 	}
 
 	mdb_merge_iterator () :
-	impl1 (std::make_unique<nano::mdb_iterator<T, U>> ()),
-	impl2 (std::make_unique<nano::mdb_iterator<T, U>> ())
+		impl1 (std::make_unique<nano::mdb_iterator<T, U>> ()),
+		impl2 (std::make_unique<nano::mdb_iterator<T, U>> ())
 	{
 	}
 
 	mdb_merge_iterator (nano::transaction const & transaction_a, MDB_dbi db1_a, MDB_dbi db2_a, MDB_val const & val_a) :
-	impl1 (std::make_unique<nano::mdb_iterator<T, U>> (transaction_a, db1_a, val_a)),
-	impl2 (std::make_unique<nano::mdb_iterator<T, U>> (transaction_a, db2_a, val_a))
+		impl1 (std::make_unique<nano::mdb_iterator<T, U>> (transaction_a, db1_a, val_a)),
+		impl2 (std::make_unique<nano::mdb_iterator<T, U>> (transaction_a, db2_a, val_a))
 	{
 	}
 
diff --git a/nano/node/lmdb/lmdb_txn.cpp b/nano/node/lmdb/lmdb_txn.cpp
index 42fc019a8e..b5b1645059 100644
--- a/nano/node/lmdb/lmdb_txn.cpp
+++ b/nano/node/lmdb/lmdb_txn.cpp
@@ -35,7 +35,7 @@ class matches_txn final
 {
 public:
 	explicit matches_txn (const nano::transaction_impl * transaction_impl_a) :
-	transaction_impl (transaction_impl_a)
+		transaction_impl (transaction_impl_a)
 	{
 	}
 
@@ -50,7 +50,7 @@ class matches_txn final
 }
 
 nano::read_mdb_txn::read_mdb_txn (nano::mdb_env const & environment_a, nano::mdb_txn_callbacks txn_callbacks_a) :
-txn_callbacks (txn_callbacks_a)
+	txn_callbacks (txn_callbacks_a)
 {
 	auto status (mdb_txn_begin (environment_a, nullptr, MDB_RDONLY, &handle));
 	release_assert (status == 0);
@@ -84,8 +84,8 @@ void * nano::read_mdb_txn::get_handle () const
 }
 
 nano::write_mdb_txn::write_mdb_txn (nano::mdb_env const & environment_a, nano::mdb_txn_callbacks txn_callbacks_a) :
-env (environment_a),
-txn_callbacks (txn_callbacks_a)
+	env (environment_a),
+	txn_callbacks (txn_callbacks_a)
 {
 	renew ();
 }
@@ -126,9 +126,9 @@ bool nano::write_mdb_txn::contains (nano::tables table_a) const
 }
 
 nano::mdb_txn_tracker::mdb_txn_tracker (nano::logger_mt & logger_a, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a) :
-logger (logger_a),
-txn_tracking_config (txn_tracking_config_a),
-block_processor_batch_max_time (block_processor_batch_max_time_a)
+	logger (logger_a),
+	txn_tracking_config (txn_tracking_config_a),
+	block_processor_batch_max_time (block_processor_batch_max_time_a)
 {
 }
 
@@ -141,7 +141,7 @@ void nano::mdb_txn_tracker::serialize_json (boost::property_tree::ptree & json,
 		nano::lock_guard<nano::mutex> guard (mutex);
 		copy_stats = stats;
 		are_writes.reserve (stats.size ());
-		std::transform (stats.cbegin (), stats.cend (), std::back_inserter (are_writes), [](auto & mdb_txn_stat) {
+		std::transform (stats.cbegin (), stats.cend (), std::back_inserter (are_writes), [] (auto & mdb_txn_stat) {
 			return mdb_txn_stat.is_write ();
 		});
 	}
@@ -149,7 +149,7 @@ void nano::mdb_txn_tracker::serialize_json (boost::property_tree::ptree & json,
 	// Get the time difference now as creating stacktraces (Debug/Windows for instance) can take a while so results won't be as accurate
 	std::vector<std::chrono::milliseconds> times_since_start;
 	times_since_start.reserve (copy_stats.size ());
-	std::transform (copy_stats.cbegin (), copy_stats.cend (), std::back_inserter (times_since_start), [](const auto & stat) {
+	std::transform (copy_stats.cbegin (), copy_stats.cend (), std::back_inserter (times_since_start), [] (const auto & stat) {
 		return stat.timer.since_start ();
 	});
 	debug_assert (times_since_start.size () == copy_stats.size ());
@@ -229,9 +229,9 @@ void nano::mdb_txn_tracker::erase (const nano::transaction_impl * transaction_im
 }
 
 nano::mdb_txn_stats::mdb_txn_stats (const nano::transaction_impl * transaction_impl) :
-transaction_impl (transaction_impl),
-thread_name (nano::thread_role::get_string ()),
-stacktrace (std::make_shared<boost::stacktrace::stacktrace> ())
+	transaction_impl (transaction_impl),
+	thread_name (nano::thread_role::get_string ()),
+	stacktrace (std::make_shared<boost::stacktrace::stacktrace> ())
 {
 	timer.start ();
 }
diff --git a/nano/node/lmdb/lmdb_txn.hpp b/nano/node/lmdb/lmdb_txn.hpp
index 9d23a65e78..a4f105044c 100644
--- a/nano/node/lmdb/lmdb_txn.hpp
+++ b/nano/node/lmdb/lmdb_txn.hpp
@@ -20,8 +20,8 @@ class mdb_env;
 class mdb_txn_callbacks
 {
 public:
-	std::function<void(const nano::transaction_impl *)> txn_start{ [](const nano::transaction_impl *) {} };
-	std::function<void(const nano::transaction_impl *)> txn_end{ [](const nano::transaction_impl *) {} };
+	std::function<void (const nano::transaction_impl *)> txn_start{ [] (const nano::transaction_impl *) {} };
+	std::function<void (const nano::transaction_impl *)> txn_end{ [] (const nano::transaction_impl *) {} };
 };
 
 class read_mdb_txn final : public read_transaction_impl
diff --git a/nano/node/lmdb/wallet_value.cpp b/nano/node/lmdb/wallet_value.cpp
index 286dc08893..c9512df636 100644
--- a/nano/node/lmdb/wallet_value.cpp
+++ b/nano/node/lmdb/wallet_value.cpp
@@ -8,8 +8,8 @@ nano::wallet_value::wallet_value (nano::db_val<MDB_val> const & val_a)
 }
 
 nano::wallet_value::wallet_value (nano::raw_key const & key_a, uint64_t work_a) :
-key (key_a),
-work (work_a)
+	key (key_a),
+	work (work_a)
 {
 }
 
diff --git a/nano/node/network.cpp b/nano/node/network.cpp
index e9ae7ea33a..93b7556456 100644
--- a/nano/node/network.cpp
+++ b/nano/node/network.cpp
@@ -12,24 +12,24 @@
 #include <numeric>
 
 nano::network::network (nano::node & node_a, uint16_t port_a) :
-syn_cookies (node_a.network_params.node.max_peers_per_ip),
-buffer_container (node_a.stats, nano::network::buffer_size, 4096), // 2Mb receive buffer
-resolver (node_a.io_ctx),
-limiter (node_a.config.bandwidth_limit_burst_ratio, node_a.config.bandwidth_limit),
-tcp_message_manager (node_a.config.tcp_incoming_connections_max),
-node (node_a),
-publish_filter (256 * 1024),
-udp_channels (node_a, port_a),
-tcp_channels (node_a),
-port (port_a),
-disconnect_observer ([]() {})
+	syn_cookies (node_a.network_params.node.max_peers_per_ip),
+	buffer_container (node_a.stats, nano::network::buffer_size, 4096), // 2Mb receive buffer
+	resolver (node_a.io_ctx),
+	limiter (node_a.config.bandwidth_limit_burst_ratio, node_a.config.bandwidth_limit),
+	tcp_message_manager (node_a.config.tcp_incoming_connections_max),
+	node (node_a),
+	publish_filter (256 * 1024),
+	udp_channels (node_a, port_a),
+	tcp_channels (node_a),
+	port (port_a),
+	disconnect_observer ([] () {})
 {
 	boost::thread::attributes attrs;
 	nano::thread_attributes::set (attrs);
 	// UDP
 	for (size_t i = 0; i < node.config.network_threads && !node.flags.disable_udp; ++i)
 	{
-		packet_processing_threads.emplace_back (attrs, [this]() {
+		packet_processing_threads.emplace_back (attrs, [this] () {
 			nano::thread_role::set (nano::thread_role::name::packet_processing);
 			try
 			{
@@ -64,7 +64,7 @@ disconnect_observer ([]() {})
 	// TCP
 	for (size_t i = 0; i < node.config.network_threads && !node.flags.disable_tcp_realtime; ++i)
 	{
-		packet_processing_threads.emplace_back (attrs, [this]() {
+		packet_processing_threads.emplace_back (attrs, [this] () {
 			nano::thread_role::set (nano::thread_role::name::packet_processing);
 			try
 			{
@@ -211,7 +211,7 @@ void nano::network::flood_vote_pr (std::shared_ptr<nano::vote> const & vote_a)
 	}
 }
 
-void nano::network::flood_block_many (std::deque<std::shared_ptr<nano::block>> blocks_a, std::function<void()> callback_a, unsigned delay_a)
+void nano::network::flood_block_many (std::deque<std::shared_ptr<nano::block>> blocks_a, std::function<void ()> callback_a, unsigned delay_a)
 {
 	if (!blocks_a.empty ())
 	{
@@ -221,7 +221,7 @@ void nano::network::flood_block_many (std::deque<std::shared_ptr<nano::block>> b
 		if (!blocks_a.empty ())
 		{
 			std::weak_ptr<nano::node> node_w (node.shared ());
-			node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (delay_a + std::rand () % delay_a), [node_w, blocks (std::move (blocks_a)), callback_a, delay_a]() {
+			node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (delay_a + std::rand () % delay_a), [node_w, blocks (std::move (blocks_a)), callback_a, delay_a] () {
 				if (auto node_l = node_w.lock ())
 				{
 					node_l->network.flood_block_many (std::move (blocks), callback_a, delay_a);
@@ -290,7 +290,7 @@ void nano::network::broadcast_confirm_req_base (std::shared_ptr<nano::block> con
 		delay_a += std::rand () % broadcast_interval_ms;
 
 		std::weak_ptr<nano::node> node_w (node.shared ());
-		node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (delay_a), [node_w, block_a, endpoints_a, delay_a]() {
+		node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (delay_a), [node_w, block_a, endpoints_a, delay_a] () {
 			if (auto node_l = node_w.lock ())
 			{
 				node_l->network.broadcast_confirm_req_base (block_a, endpoints_a, delay_a, true);
@@ -299,7 +299,7 @@ void nano::network::broadcast_confirm_req_base (std::shared_ptr<nano::block> con
 	}
 }
 
-void nano::network::broadcast_confirm_req_batched_many (std::unordered_map<std::shared_ptr<nano::transport::channel>, std::deque<std::pair<nano::block_hash, nano::root>>> request_bundle_a, std::function<void()> callback_a, unsigned delay_a, bool resumption_a)
+void nano::network::broadcast_confirm_req_batched_many (std::unordered_map<std::shared_ptr<nano::transport::channel>, std::deque<std::pair<nano::block_hash, nano::root>>> request_bundle_a, std::function<void ()> callback_a, unsigned delay_a, bool resumption_a)
 {
 	if (!resumption_a && node.config.logging.network_logging ())
 	{
@@ -330,7 +330,7 @@ void nano::network::broadcast_confirm_req_batched_many (std::unordered_map<std::
 	if (!request_bundle_a.empty ())
 	{
 		std::weak_ptr<nano::node> node_w (node.shared ());
-		node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (delay_a), [node_w, request_bundle_a, callback_a, delay_a]() {
+		node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (delay_a), [node_w, request_bundle_a, callback_a, delay_a] () {
 			if (auto node_l = node_w.lock ())
 			{
 				node_l->network.broadcast_confirm_req_batched_many (request_bundle_a, callback_a, delay_a, true);
@@ -343,7 +343,7 @@ void nano::network::broadcast_confirm_req_batched_many (std::unordered_map<std::
 	}
 }
 
-void nano::network::broadcast_confirm_req_many (std::deque<std::pair<std::shared_ptr<nano::block>, std::shared_ptr<std::vector<std::shared_ptr<nano::transport::channel>>>>> requests_a, std::function<void()> callback_a, unsigned delay_a)
+void nano::network::broadcast_confirm_req_many (std::deque<std::pair<std::shared_ptr<nano::block>, std::shared_ptr<std::vector<std::shared_ptr<nano::transport::channel>>>>> requests_a, std::function<void ()> callback_a, unsigned delay_a)
 {
 	auto pair_l (requests_a.front ());
 	requests_a.pop_front ();
@@ -359,7 +359,7 @@ void nano::network::broadcast_confirm_req_many (std::deque<std::pair<std::shared
 	if (!requests_a.empty ())
 	{
 		std::weak_ptr<nano::node> node_w (node.shared ());
-		node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (delay_a + std::rand () % delay_a), [node_w, requests_a, callback_a, delay_a]() {
+		node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (delay_a + std::rand () % delay_a), [node_w, requests_a, callback_a, delay_a] () {
 			if (auto node_l = node_w.lock ())
 			{
 				node_l->network.broadcast_confirm_req_many (requests_a, callback_a, delay_a);
@@ -378,8 +378,8 @@ class network_message_visitor : public nano::message_visitor
 {
 public:
 	network_message_visitor (nano::node & node_a, std::shared_ptr<nano::transport::channel> const & channel_a) :
-	node (node_a),
-	channel (channel_a)
+		node (node_a),
+		channel (channel_a)
 	{
 	}
 	void keepalive (nano::keepalive const & message_a) override
@@ -547,7 +547,7 @@ void nano::network::merge_peer (nano::endpoint const & peer_a)
 	if (!reachout (peer_a, node.config.allow_local_peers))
 	{
 		std::weak_ptr<nano::node> node_w (node.shared ());
-		node.network.tcp_channels.start_tcp (peer_a, [node_w](std::shared_ptr<nano::transport::channel> const & channel_a) {
+		node.network.tcp_channels.start_tcp (peer_a, [node_w] (std::shared_ptr<nano::transport::channel> const & channel_a) {
 			if (auto node_l = node_w.lock ())
 			{
 				node_l->network.send_keepalive (channel_a);
@@ -605,7 +605,7 @@ std::deque<std::shared_ptr<nano::transport::channel>> nano::network::list_non_pr
 	tcp_channels.list (result);
 	udp_channels.list (result);
 	nano::random_pool_shuffle (result.begin (), result.end ());
-	result.erase (std::remove_if (result.begin (), result.end (), [this](std::shared_ptr<nano::transport::channel> const & channel) {
+	result.erase (std::remove_if (result.begin (), result.end (), [this] (std::shared_ptr<nano::transport::channel> const & channel) {
 		return this->node.rep_crawler.is_pr (*channel);
 	}),
 	result.end ());
@@ -733,7 +733,7 @@ void nano::network::ongoing_cleanup ()
 {
 	cleanup (std::chrono::steady_clock::now () - node.network_params.node.cutoff);
 	std::weak_ptr<nano::node> node_w (node.shared ());
-	node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.period, [node_w]() {
+	node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.period, [node_w] () {
 		if (auto node_l = node_w.lock ())
 		{
 			node_l->network.ongoing_cleanup ();
@@ -745,7 +745,7 @@ void nano::network::ongoing_syn_cookie_cleanup ()
 {
 	syn_cookies.purge (std::chrono::steady_clock::now () - nano::transport::syn_cookie_cutoff);
 	std::weak_ptr<nano::node> node_w (node.shared ());
-	node.workers.add_timed_task (std::chrono::steady_clock::now () + (nano::transport::syn_cookie_cutoff * 2), [node_w]() {
+	node.workers.add_timed_task (std::chrono::steady_clock::now () + (nano::transport::syn_cookie_cutoff * 2), [node_w] () {
 		if (auto node_l = node_w.lock ())
 		{
 			node_l->network.ongoing_syn_cookie_cleanup ();
@@ -758,7 +758,7 @@ void nano::network::ongoing_keepalive ()
 	flood_keepalive (0.75f);
 	flood_keepalive_self (0.25f);
 	std::weak_ptr<nano::node> node_w (node.shared ());
-	node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.half_period, [node_w]() {
+	node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.half_period, [node_w] () {
 		if (auto node_l = node_w.lock ())
 		{
 			node_l->network.ongoing_keepalive ();
@@ -796,12 +796,12 @@ void nano::network::erase (nano::transport::channel const & channel_a)
 }
 
 nano::message_buffer_manager::message_buffer_manager (nano::stat & stats_a, size_t size, size_t count) :
-stats (stats_a),
-free (count),
-full (count),
-slab (size * count),
-entries (count),
-stopped (false)
+	stats (stats_a),
+	free (count),
+	full (count),
+	slab (size * count),
+	entries (count),
+	stopped (false)
 {
 	debug_assert (count > 0);
 	debug_assert (size > 0);
@@ -820,7 +820,7 @@ nano::message_buffer * nano::message_buffer_manager::allocate ()
 	if (!stopped && free.empty () && full.empty ())
 	{
 		stats.inc (nano::stat::type::udp, nano::stat::detail::blocking, nano::stat::dir::in);
-		condition.wait (lock, [& stopped = stopped, &free = free, &full = full] { return stopped || !free.empty () || !full.empty (); });
+		condition.wait (lock, [&stopped = stopped, &free = free, &full = full] { return stopped || !free.empty () || !full.empty (); });
 	}
 	nano::message_buffer * result (nullptr);
 	if (!free.empty ())
@@ -884,7 +884,7 @@ void nano::message_buffer_manager::stop ()
 }
 
 nano::tcp_message_manager::tcp_message_manager (unsigned incoming_connections_max_a) :
-max_entries (incoming_connections_max_a * nano::tcp_message_manager::max_entries_per_connection + 1)
+	max_entries (incoming_connections_max_a * nano::tcp_message_manager::max_entries_per_connection + 1)
 {
 	debug_assert (max_entries > 0);
 }
@@ -935,7 +935,7 @@ void nano::tcp_message_manager::stop ()
 }
 
 nano::syn_cookies::syn_cookies (size_t max_cookies_per_ip_a) :
-max_cookies_per_ip (max_cookies_per_ip_a)
+	max_cookies_per_ip (max_cookies_per_ip_a)
 {
 }
 
diff --git a/nano/node/network.hpp b/nano/node/network.hpp
index b09bc2e50d..9c7f15a14b 100644
--- a/nano/node/network.hpp
+++ b/nano/node/network.hpp
@@ -141,7 +141,7 @@ class network final
 	void flood_block_initial (std::shared_ptr<nano::block> const &);
 	// Flood block to a random selection of peers
 	void flood_block (std::shared_ptr<nano::block> const &, nano::buffer_drop_policy const = nano::buffer_drop_policy::limiter);
-	void flood_block_many (std::deque<std::shared_ptr<nano::block>>, std::function<void()> = nullptr, unsigned = broadcast_interval_ms);
+	void flood_block_many (std::deque<std::shared_ptr<nano::block>>, std::function<void ()> = nullptr, unsigned = broadcast_interval_ms);
 	void merge_peers (std::array<nano::endpoint, 8> const &);
 	void merge_peer (nano::endpoint const &);
 	void send_keepalive (std::shared_ptr<nano::transport::channel> const &);
@@ -150,8 +150,8 @@ class network final
 	void send_confirm_req (std::shared_ptr<nano::transport::channel> const & channel_a, std::pair<nano::block_hash, nano::block_hash> const & hash_root_a);
 	void broadcast_confirm_req (std::shared_ptr<nano::block> const &);
 	void broadcast_confirm_req_base (std::shared_ptr<nano::block> const &, std::shared_ptr<std::vector<std::shared_ptr<nano::transport::channel>>> const &, unsigned, bool = false);
-	void broadcast_confirm_req_batched_many (std::unordered_map<std::shared_ptr<nano::transport::channel>, std::deque<std::pair<nano::block_hash, nano::root>>>, std::function<void()> = nullptr, unsigned = broadcast_interval_ms, bool = false);
-	void broadcast_confirm_req_many (std::deque<std::pair<std::shared_ptr<nano::block>, std::shared_ptr<std::vector<std::shared_ptr<nano::transport::channel>>>>>, std::function<void()> = nullptr, unsigned = broadcast_interval_ms);
+	void broadcast_confirm_req_batched_many (std::unordered_map<std::shared_ptr<nano::transport::channel>, std::deque<std::pair<nano::block_hash, nano::root>>>, std::function<void ()> = nullptr, unsigned = broadcast_interval_ms, bool = false);
+	void broadcast_confirm_req_many (std::deque<std::pair<std::shared_ptr<nano::block>, std::shared_ptr<std::vector<std::shared_ptr<nano::transport::channel>>>>>, std::function<void ()> = nullptr, unsigned = broadcast_interval_ms);
 	std::shared_ptr<nano::transport::channel> find_node_id (nano::account const &);
 	std::shared_ptr<nano::transport::channel> find_channel (nano::endpoint const &);
 	void process_message (nano::message const &, std::shared_ptr<nano::transport::channel> const &);
@@ -190,9 +190,9 @@ class network final
 	nano::transport::udp_channels udp_channels;
 	nano::transport::tcp_channels tcp_channels;
 	std::atomic<uint16_t> port{ 0 };
-	std::function<void()> disconnect_observer;
+	std::function<void ()> disconnect_observer;
 	// Called when a new channel is observed
-	std::function<void(std::shared_ptr<nano::transport::channel>)> channel_observer;
+	std::function<void (std::shared_ptr<nano::transport::channel>)> channel_observer;
 	std::atomic<bool> stopped{ false };
 	static unsigned const broadcast_interval_ms = 10;
 	static size_t const buffer_size = 512;
diff --git a/nano/node/node.cpp b/nano/node/node.cpp
index a44f9963f1..067bf864f2 100644
--- a/nano/node/node.cpp
+++ b/nano/node/node.cpp
@@ -80,54 +80,54 @@ std::unique_ptr<nano::container_info_component> nano::collect_container_info (re
 }
 
 nano::node::node (boost::asio::io_context & io_ctx_a, uint16_t peering_port_a, boost::filesystem::path const & application_path_a, nano::logging const & logging_a, nano::work_pool & work_a, nano::node_flags flags_a, unsigned seq) :
-node (io_ctx_a, application_path_a, nano::node_config (peering_port_a, logging_a), work_a, flags_a, seq)
+	node (io_ctx_a, application_path_a, nano::node_config (peering_port_a, logging_a), work_a, flags_a, seq)
 {
 }
 
 nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path const & application_path_a, nano::node_config const & config_a, nano::work_pool & work_a, nano::node_flags flags_a, unsigned seq) :
-write_database_queue (!flags_a.force_use_write_database_queue && (config_a.rocksdb_config.enable || nano::using_rocksdb_in_tests ())),
-io_ctx (io_ctx_a),
-node_initialized_latch (1),
-config (config_a),
-stats (config.stat_config),
-workers (std::max (3u, config.io_threads / 4), nano::thread_role::name::worker),
-flags (flags_a),
-work (work_a),
-distributed_work (*this),
-logger (config_a.logging.min_time_between_log_output),
-store_impl (nano::make_store (logger, application_path_a, flags.read_only, true, config_a.rocksdb_config, config_a.diagnostics_config.txn_tracking, config_a.block_processor_batch_max_time, config_a.lmdb_config, config_a.backup_before_upgrade)),
-store (*store_impl),
-wallets_store_impl (std::make_unique<nano::mdb_wallets_store> (application_path_a / "wallets.ldb", config_a.lmdb_config)),
-wallets_store (*wallets_store_impl),
-gap_cache (*this),
-ledger (store, stats, flags_a.generate_cache),
-checker (config.signature_checker_threads),
-network (*this, config.peering_port),
-telemetry (std::make_shared<nano::telemetry> (network, workers, observers.telemetry, stats, network_params, flags.disable_ongoing_telemetry_requests)),
-bootstrap_initiator (*this),
-bootstrap (config.peering_port, *this),
-application_path (application_path_a),
-port_mapping (*this),
-rep_crawler (*this),
-vote_processor (checker, active, observers, stats, config, flags, logger, online_reps, rep_crawler, ledger, network_params),
-warmed_up (0),
-block_processor (*this, write_database_queue),
-// clang-format off
-block_processor_thread ([this]() {
-	nano::thread_role::set (nano::thread_role::name::block_processing);
-	this->block_processor.process_blocks ();
-}),
-// clang-format on
-online_reps (ledger, config),
-history{ config.network_params.voting },
-vote_uniquer (block_uniquer),
-confirmation_height_processor (ledger, write_database_queue, config.conf_height_processor_batch_min_time, config.logging, logger, node_initialized_latch, flags.confirmation_height_processor_mode),
-active (*this, confirmation_height_processor),
-scheduler{ *this },
-aggregator (network_params.network, config, stats, active.generator, history, ledger, wallets, active),
-wallets (wallets_store.init_error (), *this),
-startup_time (std::chrono::steady_clock::now ()),
-node_seq (seq)
+	write_database_queue (!flags_a.force_use_write_database_queue && (config_a.rocksdb_config.enable || nano::using_rocksdb_in_tests ())),
+	io_ctx (io_ctx_a),
+	node_initialized_latch (1),
+	config (config_a),
+	stats (config.stat_config),
+	workers (std::max (3u, config.io_threads / 4), nano::thread_role::name::worker),
+	flags (flags_a),
+	work (work_a),
+	distributed_work (*this),
+	logger (config_a.logging.min_time_between_log_output),
+	store_impl (nano::make_store (logger, application_path_a, flags.read_only, true, config_a.rocksdb_config, config_a.diagnostics_config.txn_tracking, config_a.block_processor_batch_max_time, config_a.lmdb_config, config_a.backup_before_upgrade)),
+	store (*store_impl),
+	wallets_store_impl (std::make_unique<nano::mdb_wallets_store> (application_path_a / "wallets.ldb", config_a.lmdb_config)),
+	wallets_store (*wallets_store_impl),
+	gap_cache (*this),
+	ledger (store, stats, flags_a.generate_cache),
+	checker (config.signature_checker_threads),
+	network (*this, config.peering_port),
+	telemetry (std::make_shared<nano::telemetry> (network, workers, observers.telemetry, stats, network_params, flags.disable_ongoing_telemetry_requests)),
+	bootstrap_initiator (*this),
+	bootstrap (config.peering_port, *this),
+	application_path (application_path_a),
+	port_mapping (*this),
+	rep_crawler (*this),
+	vote_processor (checker, active, observers, stats, config, flags, logger, online_reps, rep_crawler, ledger, network_params),
+	warmed_up (0),
+	block_processor (*this, write_database_queue),
+	// clang-format off
+	block_processor_thread ([this]() {
+		nano::thread_role::set (nano::thread_role::name::block_processing);
+		this->block_processor.process_blocks ();
+	}),
+	// clang-format on
+	online_reps (ledger, config),
+	history{ config.network_params.voting },
+	vote_uniquer (block_uniquer),
+	confirmation_height_processor (ledger, write_database_queue, config.conf_height_processor_batch_min_time, config.logging, logger, node_initialized_latch, flags.confirmation_height_processor_mode),
+	active (*this, confirmation_height_processor),
+	scheduler{ *this },
+	aggregator (network_params.network, config, stats, active.generator, history, ledger, wallets, active),
+	wallets (wallets_store.init_error (), *this),
+	startup_time (std::chrono::steady_clock::now ()),
+	node_seq (seq)
 {
 	if (!init_error ())
 	{
@@ -371,7 +371,7 @@ node_seq (seq)
 		{
 			std::stringstream ss;
 			ss << "Genesis block not found. This commonly indicates a configuration issue, check that the --network or --data_path command line arguments are correct, "
-			      "and also the ledger backend node config option. If using a read-only CLI command a ledger must already exist, start the node with --daemon first.";
+				  "and also the ledger backend node config option. If using a read-only CLI command a ledger must already exist, start the node with --daemon first.";
 			if (network_params.network.is_beta_network ())
 			{
 				ss << " Beta network may have reset, try clearing database files";
@@ -1553,14 +1553,14 @@ void nano::node::epoch_upgrader_impl (nano::raw_key const & prv_a, nano::epoch e
 					auto difficulty (nano::work_threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true)));
 					nano::root const & root (info.head);
 					std::shared_ptr<nano::block> epoch = builder.state ()
-					                                     .account (account)
-					                                     .previous (info.head)
-					                                     .representative (info.representative)
-					                                     .balance (info.balance)
-					                                     .link (link)
-					                                     .sign (raw_key, signer)
-					                                     .work (0)
-					                                     .build ();
+														 .account (account)
+														 .previous (info.head)
+														 .representative (info.representative)
+														 .balance (info.balance)
+														 .link (link)
+														 .sign (raw_key, signer)
+														 .work (0)
+														 .build ();
 					if (threads != 0)
 					{
 						{
@@ -1632,14 +1632,14 @@ void nano::node::epoch_upgrader_impl (nano::raw_key const & prv_a, nano::epoch e
 						nano::root const & root (key.account);
 						nano::account const & account (key.account);
 						std::shared_ptr<nano::block> epoch = builder.state ()
-						                                     .account (key.account)
-						                                     .previous (0)
-						                                     .representative (0)
-						                                     .balance (0)
-						                                     .link (link)
-						                                     .sign (raw_key, signer)
-						                                     .work (0)
-						                                     .build ();
+															 .account (key.account)
+															 .previous (0)
+															 .representative (0)
+															 .balance (0)
+															 .link (link)
+															 .sign (raw_key, signer)
+															 .work (0)
+															 .build ();
 						if (threads != 0)
 						{
 							{
@@ -1766,8 +1766,8 @@ void nano::node::populate_backlog ()
 }
 
 nano::node_wrapper::node_wrapper (boost::filesystem::path const & path_a, boost::filesystem::path const & config_path_a, nano::node_flags const & node_flags_a) :
-io_context (std::make_shared<boost::asio::io_context> ()),
-work (1)
+	io_context (std::make_shared<boost::asio::io_context> ()),
+	work (1)
 {
 	boost::system::error_code error_chmod;
 
@@ -1786,7 +1786,7 @@ work (1)
 			std::cerr << " or --config option";
 		}
 		std::cerr << "\n"
-		          << error.get_message () << std::endl;
+				  << error.get_message () << std::endl;
 		std::exit (1);
 	}
 
@@ -1804,14 +1804,14 @@ nano::node_wrapper::~node_wrapper ()
 }
 
 nano::inactive_node::inactive_node (boost::filesystem::path const & path_a, boost::filesystem::path const & config_path_a, nano::node_flags const & node_flags_a) :
-node_wrapper (path_a, config_path_a, node_flags_a),
-node (node_wrapper.node)
+	node_wrapper (path_a, config_path_a, node_flags_a),
+	node (node_wrapper.node)
 {
 	node_wrapper.node->active.stop ();
 }
 
 nano::inactive_node::inactive_node (boost::filesystem::path const & path_a, nano::node_flags const & node_flags_a) :
-inactive_node (path_a, path_a, node_flags_a)
+	inactive_node (path_a, path_a, node_flags_a)
 {
 }
 
diff --git a/nano/node/node_rpc_config.cpp b/nano/node/node_rpc_config.cpp
index cd327add26..c83f8c0904 100644
--- a/nano/node/node_rpc_config.cpp
+++ b/nano/node/node_rpc_config.cpp
@@ -57,7 +57,7 @@ nano::error nano::node_rpc_config::deserialize_json (bool & upgraded_a, nano::js
 	return json.get_error ();
 }
 
-void nano::node_rpc_config::set_request_callback (std::function<void(boost::property_tree::ptree const &)> callback_a)
+void nano::node_rpc_config::set_request_callback (std::function<void (boost::property_tree::ptree const &)> callback_a)
 {
 	debug_assert (nano::network_constants ().is_dev_network ());
 	request_callback = std::move (callback_a);
diff --git a/nano/node/node_rpc_config.hpp b/nano/node/node_rpc_config.hpp
index 29a85122b3..8753296147 100644
--- a/nano/node/node_rpc_config.hpp
+++ b/nano/node/node_rpc_config.hpp
@@ -40,7 +40,7 @@ class node_rpc_config final
 	}
 
 	// Used in tests to ensure requests are modified in specific cases
-	void set_request_callback (std::function<void(boost::property_tree::ptree const &)>);
-	std::function<void(boost::property_tree::ptree const &)> request_callback;
+	void set_request_callback (std::function<void (boost::property_tree::ptree const &)>);
+	std::function<void (boost::property_tree::ptree const &)> request_callback;
 };
 }
diff --git a/nano/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp
index 7019718b29..03cb9f312c 100644
--- a/nano/node/nodeconfig.cpp
+++ b/nano/node/nodeconfig.cpp
@@ -21,14 +21,14 @@ const std::string default_test_peer_network = nano::get_env_or_default ("NANO_TE
 }
 
 nano::node_config::node_config () :
-node_config (0, nano::logging ())
+	node_config (0, nano::logging ())
 {
 }
 
 nano::node_config::node_config (uint16_t peering_port_a, nano::logging const & logging_a) :
-peering_port (peering_port_a),
-logging (logging_a),
-external_address (boost::asio::ip::address_v6{}.to_string ())
+	peering_port (peering_port_a),
+	logging (logging_a),
+	external_address (boost::asio::ip::address_v6{}.to_string ())
 {
 	// The default constructor passes 0 to indicate we should use the default port,
 	// which is determined at node startup based on active network.
@@ -230,7 +230,7 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml)
 		if (toml.has_key ("work_peers"))
 		{
 			work_peers.clear ();
-			toml.array_entries_required<std::string> ("work_peers", [this](std::string const & entry_a) {
+			toml.array_entries_required<std::string> ("work_peers", [this] (std::string const & entry_a) {
 				this->deserialize_address (entry_a, this->work_peers);
 			});
 		}
@@ -238,7 +238,7 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml)
 		if (toml.has_key (preconfigured_peers_key))
 		{
 			preconfigured_peers.clear ();
-			toml.array_entries_required<std::string> (preconfigured_peers_key, [this](std::string entry) {
+			toml.array_entries_required<std::string> (preconfigured_peers_key, [this] (std::string entry) {
 				preconfigured_peers.push_back (entry);
 			});
 		}
@@ -246,7 +246,7 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml)
 		if (toml.has_key ("preconfigured_representatives"))
 		{
 			preconfigured_representatives.clear ();
-			toml.array_entries_required<std::string> ("preconfigured_representatives", [this, &toml](std::string entry) {
+			toml.array_entries_required<std::string> ("preconfigured_representatives", [this, &toml] (std::string entry) {
 				nano::account representative (0);
 				if (representative.decode_account (entry))
 				{
@@ -389,7 +389,7 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml)
 			if (experimental_config_l.has_key ("secondary_work_peers"))
 			{
 				secondary_work_peers.clear ();
-				experimental_config_l.array_entries_required<std::string> ("secondary_work_peers", [this](std::string const & entry_a) {
+				experimental_config_l.array_entries_required<std::string> ("secondary_work_peers", [this] (std::string const & entry_a) {
 					this->deserialize_address (entry_a, this->secondary_work_peers);
 				});
 			}
@@ -585,7 +585,7 @@ nano::error nano::node_config::deserialize_json (bool & upgraded_a, nano::jsonco
 
 		work_peers.clear ();
 		auto work_peers_l (json.get_required_child ("work_peers"));
-		work_peers_l.array_entries<std::string> ([this](std::string entry) {
+		work_peers_l.array_entries<std::string> ([this] (std::string entry) {
 			auto port_position (entry.rfind (':'));
 			bool result = port_position == -1;
 			if (!result)
@@ -603,13 +603,13 @@ nano::error nano::node_config::deserialize_json (bool & upgraded_a, nano::jsonco
 
 		auto preconfigured_peers_l (json.get_required_child (preconfigured_peers_key));
 		preconfigured_peers.clear ();
-		preconfigured_peers_l.array_entries<std::string> ([this](std::string entry) {
+		preconfigured_peers_l.array_entries<std::string> ([this] (std::string entry) {
 			preconfigured_peers.push_back (entry);
 		});
 
 		auto preconfigured_representatives_l (json.get_required_child ("preconfigured_representatives"));
 		preconfigured_representatives.clear ();
-		preconfigured_representatives_l.array_entries<std::string> ([this, &json](std::string entry) {
+		preconfigured_representatives_l.array_entries<std::string> ([this, &json] (std::string entry) {
 			nano::account representative (0);
 			if (representative.decode_account (entry))
 			{
diff --git a/nano/node/online_reps.cpp b/nano/node/online_reps.cpp
index 533b2ccb21..774b81dfb4 100644
--- a/nano/node/online_reps.cpp
+++ b/nano/node/online_reps.cpp
@@ -4,8 +4,8 @@
 #include <nano/secure/ledger.hpp>
 
 nano::online_reps::online_reps (nano::ledger & ledger_a, nano::node_config const & config_a) :
-ledger{ ledger_a },
-config{ config_a }
+	ledger{ ledger_a },
+	config{ config_a }
 {
 	if (!ledger.store.init_error ())
 	{
@@ -105,7 +105,7 @@ std::vector<nano::account> nano::online_reps::list ()
 {
 	std::vector<nano::account> result;
 	nano::lock_guard<nano::mutex> lock (mutex);
-	std::for_each (reps.begin (), reps.end (), [&result](rep_info const & info_a) { result.push_back (info_a.account); });
+	std::for_each (reps.begin (), reps.end (), [&result] (rep_info const & info_a) { result.push_back (info_a.account); });
 	return result;
 }
 
diff --git a/nano/node/openclconfig.cpp b/nano/node/openclconfig.cpp
index 4af49333f4..5b8b3c6c5f 100644
--- a/nano/node/openclconfig.cpp
+++ b/nano/node/openclconfig.cpp
@@ -3,9 +3,9 @@
 #include <nano/node/openclconfig.hpp>
 
 nano::opencl_config::opencl_config (unsigned platform_a, unsigned device_a, unsigned threads_a) :
-platform (platform_a),
-device (device_a),
-threads (threads_a)
+	platform (platform_a),
+	device (device_a),
+	threads (threads_a)
 {
 }
 
diff --git a/nano/node/openclwork.cpp b/nano/node/openclwork.cpp
index 589fa166ae..755c476a0b 100644
--- a/nano/node/openclwork.cpp
+++ b/nano/node/openclwork.cpp
@@ -251,16 +251,16 @@ void nano::opencl_environment::dump (std::ostream & stream)
 }
 
 nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & config_a, nano::opencl_environment & environment_a, nano::logger_mt & logger_a) :
-config (config_a),
-context (0),
-attempt_buffer (0),
-result_buffer (0),
-item_buffer (0),
-difficulty_buffer (0),
-program (0),
-kernel (0),
-queue (0),
-logger (logger_a)
+	config (config_a),
+	context (0),
+	attempt_buffer (0),
+	result_buffer (0),
+	item_buffer (0),
+	difficulty_buffer (0),
+	program (0),
+	kernel (0),
+	queue (0),
+	logger (logger_a)
 {
 	error_a |= config.platform >= environment_a.platforms.size ();
 	if (!error_a)
diff --git a/nano/node/peer_exclusion.cpp b/nano/node/peer_exclusion.cpp
index bb3122f1c5..1ac29e26a8 100644
--- a/nano/node/peer_exclusion.cpp
+++ b/nano/node/peer_exclusion.cpp
@@ -30,7 +30,7 @@ uint64_t nano::peer_exclusion::add (nano::tcp_endpoint const & endpoint_a, size_
 	else
 	{
 		// Update existing endpoint
-		peers_by_endpoint.modify (existing, [&result](peer_exclusion::item & item_a) {
+		peers_by_endpoint.modify (existing, [&result] (peer_exclusion::item & item_a) {
 			++item_a.score;
 			result = item_a.score;
 			if (item_a.score == peer_exclusion::score_limit)
diff --git a/nano/node/plat/windows/openclapi.cpp b/nano/node/plat/windows/openclapi.cpp
index 8b71e2689b..290663a059 100644
--- a/nano/node/plat/windows/openclapi.cpp
+++ b/nano/node/plat/windows/openclapi.cpp
@@ -47,11 +47,11 @@ class opencl_initializer
 	cl_int (CL_API_CALL * clGetPlatformInfo) (cl_platform_id, cl_platform_info, size_t, void *, size_t *);
 	cl_int (CL_API_CALL * clGetDeviceIDs) (cl_platform_id, cl_device_type, cl_uint, cl_device_id *, cl_uint *);
 	cl_int (CL_API_CALL * clGetDeviceInfo) (cl_device_id, cl_device_info, size_t, void *, size_t *);
-	cl_context (CL_API_CALL * clCreateContext) (cl_context_properties const *, cl_uint, cl_device_id const *, void(CL_CALLBACK *) (const char *, const void *, size_t, void *), void *, cl_int *);
+	cl_context (CL_API_CALL * clCreateContext) (cl_context_properties const *, cl_uint, cl_device_id const *, void (CL_CALLBACK *) (const char *, const void *, size_t, void *), void *, cl_int *);
 	cl_command_queue (CL_API_CALL * clCreateCommandQueue) (cl_context, cl_device_id, cl_command_queue_properties, cl_int *);
 	cl_mem (CL_API_CALL * clCreateBuffer) (cl_context, cl_mem_flags, size_t, void *, cl_int *);
 	cl_program (CL_API_CALL * clCreateProgramWithSource) (cl_context, cl_uint, char const **, size_t const *, cl_int *);
-	cl_int (CL_API_CALL * clBuildProgram) (cl_program, cl_uint, cl_device_id const *, char const *, void(CL_CALLBACK *) (cl_program, void *), void *);
+	cl_int (CL_API_CALL * clBuildProgram) (cl_program, cl_uint, cl_device_id const *, char const *, void (CL_CALLBACK *) (cl_program, void *), void *);
 	cl_int (CL_API_CALL * clGetProgramBuildInfo) (cl_program, cl_device_id, cl_program_build_info, size_t, void *, size_t *);
 	cl_kernel (CL_API_CALL * clCreateKernel) (cl_program, char const *, cl_int *);
 	cl_int (CL_API_CALL * clSetKernelArg) (cl_kernel, cl_uint, size_t, void const *);
@@ -101,7 +101,7 @@ cl_int CL_API_CALL clGetDeviceInfo (cl_device_id device, cl_device_info param_na
 	return opencl_initializer::initializer.clGetDeviceInfo (device, param_name, param_value_size, param_value, param_value_size_ret);
 }
 
-cl_context CL_API_CALL clCreateContext (cl_context_properties const * properties, cl_uint num_devices, cl_device_id const * devices, void(CL_CALLBACK * pfn_notify) (const char *, const void *, size_t, void *), void * user_data, cl_int * errcode_ret)
+cl_context CL_API_CALL clCreateContext (cl_context_properties const * properties, cl_uint num_devices, cl_device_id const * devices, void (CL_CALLBACK * pfn_notify) (const char *, const void *, size_t, void *), void * user_data, cl_int * errcode_ret)
 {
 	return opencl_initializer::initializer.clCreateContext (properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
 }
@@ -121,7 +121,7 @@ cl_program CL_API_CALL clCreateProgramWithSource (cl_context context, cl_uint co
 	return opencl_initializer::initializer.clCreateProgramWithSource (context, count, strings, lengths, errcode_ret);
 }
 
-cl_int CL_API_CALL clBuildProgram (cl_program program, cl_uint num_devices, cl_device_id const * device_list, char const * options, void(CL_CALLBACK * pfn_notify) (cl_program, void *), void * user_data)
+cl_int CL_API_CALL clBuildProgram (cl_program program, cl_uint num_devices, cl_device_id const * device_list, char const * options, void (CL_CALLBACK * pfn_notify) (cl_program, void *), void * user_data)
 {
 	return opencl_initializer::initializer.clBuildProgram (program, num_devices, device_list, options, pfn_notify, user_data);
 }
diff --git a/nano/node/portmapping.cpp b/nano/node/portmapping.cpp
index f38a0542c8..b53199c1eb 100644
--- a/nano/node/portmapping.cpp
+++ b/nano/node/portmapping.cpp
@@ -8,8 +8,8 @@
 #include <upnperrors.h>
 
 nano::port_mapping::port_mapping (nano::node & node_a) :
-node (node_a),
-protocols ({ { { "TCP", boost::asio::ip::address_v4::any (), 0, true }, { "UDP", boost::asio::ip::address_v4::any (), 0, !node_a.flags.disable_udp } } })
+	node (node_a),
+	protocols ({ { { "TCP", boost::asio::ip::address_v4::any (), 0, true }, { "UDP", boost::asio::ip::address_v4::any (), 0, !node_a.flags.disable_udp } } })
 {
 }
 
@@ -62,7 +62,7 @@ nano::endpoint nano::port_mapping::external_address ()
 {
 	nano::endpoint result_l (boost::asio::ip::address_v6{}, 0);
 	nano::lock_guard<nano::mutex> guard_l (mutex);
-	for (auto & protocol : protocols | boost::adaptors::filtered ([](auto const & p) { return p.enabled; }))
+	for (auto & protocol : protocols | boost::adaptors::filtered ([] (auto const & p) { return p.enabled; }))
 	{
 		if (protocol.external_port != 0)
 		{
@@ -82,7 +82,7 @@ void nano::port_mapping::refresh_mapping ()
 		auto config_port_l (get_config_port (node_port_l));
 
 		// We don't map the RPC port because, unless RPC authentication was added, this would almost always be a security risk
-		for (auto & protocol : protocols | boost::adaptors::filtered ([](auto const & p) { return p.enabled; }))
+		for (auto & protocol : protocols | boost::adaptors::filtered ([] (auto const & p) { return p.enabled; }))
 		{
 			auto upnp_description = std::string ("Nano Node (") + network_params.network.get_current_network_as_string () + ")";
 			auto add_port_mapping_error_l (UPNP_AddPortMapping (upnp.urls.controlURL, upnp.data.first.servicetype, config_port_l.c_str (), node_port_l.c_str (), address.to_string ().c_str (), upnp_description.c_str (), protocol.name, nullptr, std::to_string (network_params.portmapping.lease_duration.count ()).c_str ()));
@@ -96,7 +96,7 @@ void nano::port_mapping::refresh_mapping ()
 				node.logger.always_log (boost::str (boost::format ("UPnP %1%:%2% mapped to %3%") % protocol.external_address % config_port_l % node_port_l));
 
 				// Refresh mapping before the leasing ends
-				node.workers.add_timed_task (std::chrono::steady_clock::now () + network_params.portmapping.lease_duration - std::chrono::seconds (10), [node_l = node.shared ()]() {
+				node.workers.add_timed_task (std::chrono::steady_clock::now () + network_params.portmapping.lease_duration - std::chrono::seconds (10), [node_l = node.shared ()] () {
 					node_l->port_mapping.refresh_mapping ();
 				});
 			}
@@ -117,7 +117,7 @@ bool nano::port_mapping::check_mapping ()
 	nano::lock_guard<nano::mutex> guard_l (mutex);
 	auto node_port_l (std::to_string (node.network.endpoint ().port ()));
 	auto config_port_l (get_config_port (node_port_l));
-	for (auto & protocol : protocols | boost::adaptors::filtered ([](auto const & p) { return p.enabled; }))
+	for (auto & protocol : protocols | boost::adaptors::filtered ([] (auto const & p) { return p.enabled; }))
 	{
 		std::array<char, 64> int_client_l;
 		std::array<char, 6> int_port_l;
@@ -166,7 +166,7 @@ void nano::port_mapping::check_mapping_loop ()
 			refresh_mapping ();
 		}
 		// Check for mapping health frequently
-		node.workers.add_timed_task (std::chrono::steady_clock::now () + network_params.portmapping.health_check_period, [node_l = node.shared ()]() {
+		node.workers.add_timed_task (std::chrono::steady_clock::now () + network_params.portmapping.health_check_period, [node_l = node.shared ()] () {
 			node_l->port_mapping.check_mapping_loop ();
 		});
 	}
@@ -177,7 +177,7 @@ void nano::port_mapping::check_mapping_loop ()
 			node.logger.always_log (boost::str (boost::format ("UPnP No IGD devices found")));
 		}
 		// Check for new devices later
-		node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::minutes (5), [node_l = node.shared ()]() {
+		node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::minutes (5), [node_l = node.shared ()] () {
 			node_l->port_mapping.check_mapping_loop ();
 		});
 	}
@@ -188,7 +188,7 @@ void nano::port_mapping::stop ()
 {
 	on = false;
 	nano::lock_guard<nano::mutex> guard_l (mutex);
-	for (auto & protocol : protocols | boost::adaptors::filtered ([](auto const & p) { return p.enabled; }))
+	for (auto & protocol : protocols | boost::adaptors::filtered ([] (auto const & p) { return p.enabled; }))
 	{
 		if (protocol.external_port != 0)
 		{
diff --git a/nano/node/prioritization.cpp b/nano/node/prioritization.cpp
index 7c73f3ba55..d0677a73d2 100644
--- a/nano/node/prioritization.cpp
+++ b/nano/node/prioritization.cpp
@@ -41,8 +41,8 @@ void nano::prioritization::populate_schedule ()
 }
 
 nano::prioritization::prioritization (uint64_t maximum, std::function<void (std::shared_ptr<nano::block>)> const & drop_a) :
-drop{ drop_a },
-maximum{ maximum }
+	drop{ drop_a },
+	maximum{ maximum }
 {
 	static size_t constexpr bucket_count = 129;
 	buckets.resize (bucket_count);
diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp
index d34c36eaa8..9061f8f52a 100644
--- a/nano/node/repcrawler.cpp
+++ b/nano/node/repcrawler.cpp
@@ -4,11 +4,11 @@
 #include <boost/format.hpp>
 
 nano::rep_crawler::rep_crawler (nano::node & node_a) :
-node (node_a)
+	node (node_a)
 {
 	if (!node.flags.disable_rep_crawler)
 	{
-		node.observers.endpoint.add ([this](std::shared_ptr<nano::transport::channel> const & channel_a) {
+		node.observers.endpoint.add ([this] (std::shared_ptr<nano::transport::channel> const & channel_a) {
 			this->query (channel_a);
 		});
 	}
@@ -48,7 +48,7 @@ void nano::rep_crawler::validate ()
 				auto existing (probable_reps.find (vote->account));
 				if (existing != probable_reps.end ())
 				{
-					probable_reps.modify (existing, [rep_weight, &updated_or_inserted, &vote, &channel](nano::representative & info) {
+					probable_reps.modify (existing, [rep_weight, &updated_or_inserted, &vote, &channel] (nano::representative & info) {
 						info.last_response = std::chrono::steady_clock::now ();
 
 						// Update if representative channel was changed
@@ -93,7 +93,7 @@ void nano::rep_crawler::ongoing_crawl ()
 	// Reduce crawl frequency when there's enough total peer weight
 	unsigned next_run_ms = node.network_params.network.is_dev_network () ? 100 : sufficient_weight ? 7000 : 3000;
 	std::weak_ptr<nano::node> node_w (node.shared ());
-	node.workers.add_timed_task (now + std::chrono::milliseconds (next_run_ms), [node_w, this]() {
+	node.workers.add_timed_task (now + std::chrono::milliseconds (next_run_ms), [node_w, this] () {
 		if (auto node_l = node_w.lock ())
 		{
 			this->ongoing_crawl ();
@@ -152,7 +152,7 @@ void nano::rep_crawler::query (std::vector<std::shared_ptr<nano::transport::chan
 
 	// A representative must respond with a vote within the deadline
 	std::weak_ptr<nano::node> node_w (node.shared ());
-	node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [node_w, hash = hash_root.first]() {
+	node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [node_w, hash = hash_root.first] () {
 		if (auto node_l = node_w.lock ())
 		{
 			auto target_finished_processed (node_l->vote_processor.total_processed + node_l->vote_processor.size ());
@@ -177,7 +177,7 @@ void nano::rep_crawler::throttled_remove (nano::block_hash const & hash_a, uint6
 	else
 	{
 		std::weak_ptr<nano::node> node_w (node.shared ());
-		node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [node_w, hash_a, target_finished_processed]() {
+		node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [node_w, hash_a, target_finished_processed] () {
 			if (auto node_l = node_w.lock ())
 			{
 				node_l->rep_crawler.throttled_remove (hash_a, target_finished_processed);
@@ -244,7 +244,7 @@ void nano::rep_crawler::on_rep_request (std::shared_ptr<nano::transport::channel
 		auto itr_pair = channel_ref_index.equal_range (*channel_a);
 		for (; itr_pair.first != itr_pair.second; itr_pair.first++)
 		{
-			channel_ref_index.modify (itr_pair.first, [](nano::representative & value_a) {
+			channel_ref_index.modify (itr_pair.first, [] (nano::representative & value_a) {
 				value_a.last_request = std::chrono::steady_clock::now ();
 			});
 		}
@@ -310,7 +310,7 @@ void nano::rep_crawler::update_weights ()
 		{
 			if (i->weight.number () != weight)
 			{
-				probable_reps.get<tag_last_request> ().modify (i, [weight](nano::representative & info) {
+				probable_reps.get<tag_last_request> ().modify (i, [weight] (nano::representative & info) {
 					info.weight = weight;
 				});
 			}
diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp
index bbfeb4744e..678fe08b4f 100644
--- a/nano/node/repcrawler.hpp
+++ b/nano/node/repcrawler.hpp
@@ -29,7 +29,7 @@ class representative
 public:
 	representative () = default;
 	representative (nano::account account_a, nano::amount weight_a, std::shared_ptr<nano::transport::channel> const & channel_a) :
-	account (account_a), weight (weight_a), channel (channel_a)
+		account (account_a), weight (weight_a), channel (channel_a)
 	{
 		debug_assert (channel != nullptr);
 	}
diff --git a/nano/node/request_aggregator.cpp b/nano/node/request_aggregator.cpp
index 815d6b4ee2..e9c0ec94e3 100644
--- a/nano/node/request_aggregator.cpp
+++ b/nano/node/request_aggregator.cpp
@@ -12,22 +12,22 @@
 #include <nano/secure/ledger.hpp>
 
 nano::request_aggregator::request_aggregator (nano::network_constants const & network_constants_a, nano::node_config const & config_a, nano::stat & stats_a, nano::vote_generator & generator_a, nano::local_vote_history & history_a, nano::ledger & ledger_a, nano::wallets & wallets_a, nano::active_transactions & active_a) :
-max_delay (network_constants_a.is_dev_network () ? 50 : 300),
-small_delay (network_constants_a.is_dev_network () ? 10 : 50),
-max_channel_requests (config_a.max_queued_requests),
-stats (stats_a),
-local_votes (history_a),
-ledger (ledger_a),
-wallets (wallets_a),
-active (active_a),
-generator (generator_a),
-thread ([this]() { run (); })
+	max_delay (network_constants_a.is_dev_network () ? 50 : 300),
+	small_delay (network_constants_a.is_dev_network () ? 10 : 50),
+	max_channel_requests (config_a.max_queued_requests),
+	stats (stats_a),
+	local_votes (history_a),
+	ledger (ledger_a),
+	wallets (wallets_a),
+	active (active_a),
+	generator (generator_a),
+	thread ([this] () { run (); })
 {
-	generator.set_reply_action ([this](std::shared_ptr<nano::vote> const & vote_a, std::shared_ptr<nano::transport::channel> const & channel_a) {
+	generator.set_reply_action ([this] (std::shared_ptr<nano::vote> const & vote_a, std::shared_ptr<nano::transport::channel> const & channel_a) {
 		this->reply_action (vote_a, channel_a);
 	});
 	nano::unique_lock<nano::mutex> lock (mutex);
-	condition.wait (lock, [& started = started] { return started; });
+	condition.wait (lock, [&started = started] { return started; });
 }
 
 void nano::request_aggregator::add (std::shared_ptr<nano::transport::channel> const & channel_a, std::vector<std::pair<nano::block_hash, nano::root>> const & hashes_roots_a)
@@ -46,7 +46,7 @@ void nano::request_aggregator::add (std::shared_ptr<nano::transport::channel> co
 		{
 			existing = requests_by_endpoint.emplace (channel_a).first;
 		}
-		requests_by_endpoint.modify (existing, [&hashes_roots_a, &channel_a, &error, this](channel_pool & pool_a) {
+		requests_by_endpoint.modify (existing, [&hashes_roots_a, &channel_a, &error, this] (channel_pool & pool_a) {
 			// This extends the lifetime of the channel, which is acceptable up to max_delay
 			pool_a.channel = channel_a;
 			if (pool_a.hashes_roots.size () + hashes_roots_a.size () <= this->max_channel_requests)
@@ -85,7 +85,7 @@ void nano::request_aggregator::run ()
 				// Store the channel and requests for processing after erasing this pool
 				decltype (front->channel) channel{};
 				decltype (front->hashes_roots) hashes_roots{};
-				requests_by_deadline.modify (front, [&channel, &hashes_roots](channel_pool & pool) {
+				requests_by_deadline.modify (front, [&channel, &hashes_roots] (channel_pool & pool) {
 					channel.swap (pool.channel);
 					hashes_roots.swap (pool.hashes_roots);
 				});
@@ -104,12 +104,12 @@ void nano::request_aggregator::run ()
 			else
 			{
 				auto deadline = front->deadline;
-				condition.wait_until (lock, deadline, [this, &deadline]() { return this->stopped || deadline < std::chrono::steady_clock::now (); });
+				condition.wait_until (lock, deadline, [this, &deadline] () { return this->stopped || deadline < std::chrono::steady_clock::now (); });
 			}
 		}
 		else
 		{
-			condition.wait_for (lock, small_delay, [this]() { return this->stopped || !this->requests.empty (); });
+			condition.wait_for (lock, small_delay, [this] () { return this->stopped || !this->requests.empty (); });
 		}
 	}
 }
@@ -146,10 +146,10 @@ void nano::request_aggregator::reply_action (std::shared_ptr<nano::vote> const &
 
 void nano::request_aggregator::erase_duplicates (std::vector<std::pair<nano::block_hash, nano::root>> & requests_a) const
 {
-	std::sort (requests_a.begin (), requests_a.end (), [](auto const & pair1, auto const & pair2) {
+	std::sort (requests_a.begin (), requests_a.end (), [] (auto const & pair1, auto const & pair2) {
 		return pair1.first < pair2.first;
 	});
-	requests_a.erase (std::unique (requests_a.begin (), requests_a.end (), [](auto const & pair1, auto const & pair2) {
+	requests_a.erase (std::unique (requests_a.begin (), requests_a.end (), [] (auto const & pair1, auto const & pair2) {
 		return pair1.first == pair2.first;
 	}),
 	requests_a.end ());
diff --git a/nano/node/request_aggregator.hpp b/nano/node/request_aggregator.hpp
index 6e9edfe6f6..ae9e18e5e6 100644
--- a/nano/node/request_aggregator.hpp
+++ b/nano/node/request_aggregator.hpp
@@ -42,8 +42,8 @@ class request_aggregator final
 	{
 		channel_pool () = delete;
 		explicit channel_pool (std::shared_ptr<nano::transport::channel> const & channel_a) :
-		channel (channel_a),
-		endpoint (nano::transport::map_endpoint_to_v6 (channel_a->get_endpoint ()))
+			channel (channel_a),
+			endpoint (nano::transport::map_endpoint_to_v6 (channel_a->get_endpoint ()))
 		{
 		}
 		std::vector<std::pair<nano::block_hash, nano::root>> hashes_roots;
diff --git a/nano/node/rocksdb/rocksdb.cpp b/nano/node/rocksdb/rocksdb.cpp
index d5867bdf5c..a46bb3551c 100644
--- a/nano/node/rocksdb/rocksdb.cpp
+++ b/nano/node/rocksdb/rocksdb.cpp
@@ -21,8 +21,8 @@ namespace
 class event_listener : public rocksdb::EventListener
 {
 public:
-	event_listener (std::function<void(rocksdb::FlushJobInfo const &)> const & flush_completed_cb_a) :
-	flush_completed_cb (flush_completed_cb_a)
+	event_listener (std::function<void (rocksdb::FlushJobInfo const &)> const & flush_completed_cb_a) :
+		flush_completed_cb (flush_completed_cb_a)
 	{
 	}
 
@@ -32,7 +32,7 @@ class event_listener : public rocksdb::EventListener
 	}
 
 private:
-	std::function<void(rocksdb::FlushJobInfo const &)> flush_completed_cb;
+	std::function<void (rocksdb::FlushJobInfo const &)> flush_completed_cb;
 };
 }
 
@@ -52,7 +52,7 @@ size_t rocksdb_val::size () const
 
 template <>
 rocksdb_val::db_val (size_t size_a, void * data_a) :
-value (static_cast<const char *> (data_a), size_a)
+	value (static_cast<const char *> (data_a), size_a)
 {
 }
 
@@ -64,10 +64,10 @@ void rocksdb_val::convert_buffer_to_value ()
 }
 
 nano::rocksdb_store::rocksdb_store (nano::logger_mt & logger_a, boost::filesystem::path const & path_a, nano::rocksdb_config const & rocksdb_config_a, bool open_read_only_a) :
-logger{ logger_a },
-rocksdb_config{ rocksdb_config_a },
-max_block_write_batch_num_m{ nano::narrow_cast<unsigned> (blocks_memtable_size_bytes () / (2 * (sizeof (nano::block_type) + nano::state_block::size + nano::block_sideband::size (nano::block_type::state)))) },
-cf_name_table_map{ create_cf_name_table_map () }
+	logger{ logger_a },
+	rocksdb_config{ rocksdb_config_a },
+	max_block_write_batch_num_m{ nano::narrow_cast<unsigned> (blocks_memtable_size_bytes () / (2 * (sizeof (nano::block_type) + nano::state_block::size + nano::block_sideband::size (nano::block_type::state)))) },
+	cf_name_table_map{ create_cf_name_table_map () }
 {
 	boost::system::error_code error_mkdir, error_chmod;
 	boost::filesystem::create_directories (path_a, error_mkdir);
@@ -329,8 +329,8 @@ std::string nano::rocksdb_store::vendor_get () const
 rocksdb::ColumnFamilyHandle * nano::rocksdb_store::table_to_column_family (tables table_a) const
 {
 	auto & handles_l = handles;
-	auto get_handle = [&handles_l](const char * name) {
-		auto iter = std::find_if (handles_l.begin (), handles_l.end (), [name](auto & handle) {
+	auto get_handle = [&handles_l] (const char * name) {
+		auto iter = std::find_if (handles_l.begin (), handles_l.end (), [name] (auto & handle) {
 			return (handle->GetName () == name);
 		});
 		debug_assert (iter != handles_l.end ());
@@ -580,7 +580,7 @@ int nano::rocksdb_store::clear (rocksdb::ColumnFamilyHandle * column_family)
 	release_assert (status.ok ());
 
 	// Need to add it back as we just want to clear the contents
-	auto handle_it = std::find_if (handles.begin (), handles.end (), [column_family](auto & handle) {
+	auto handle_it = std::find_if (handles.begin (), handles.end (), [column_family] (auto & handle) {
 		return handle.get () == column_family;
 	});
 	debug_assert (handle_it != handles.cend ());
@@ -669,7 +669,7 @@ rocksdb::Options nano::rocksdb_store::get_db_options ()
 	// Not compressing any SST files for compatibility reasons.
 	db_options.compression = rocksdb::kNoCompression;
 
-	auto event_listener_l = new event_listener ([this](rocksdb::FlushJobInfo const & flush_job_info_a) { this->on_flush (flush_job_info_a); });
+	auto event_listener_l = new event_listener ([this] (rocksdb::FlushJobInfo const & flush_job_info_a) { this->on_flush (flush_job_info_a); });
 	db_options.listeners.emplace_back (event_listener_l);
 
 	return db_options;
@@ -907,8 +907,8 @@ std::string nano::rocksdb_store::error_string (int status) const
 }
 
 nano::rocksdb_store::tombstone_info::tombstone_info (uint64_t num_since_last_flush_a, uint64_t const max_a) :
-num_since_last_flush (num_since_last_flush_a),
-max (max_a)
+	num_since_last_flush (num_since_last_flush_a),
+	max (max_a)
 {
 }
 
diff --git a/nano/node/rocksdb/rocksdb_iterator.hpp b/nano/node/rocksdb/rocksdb_iterator.hpp
index 5a3a8795c8..263e910b69 100644
--- a/nano/node/rocksdb/rocksdb_iterator.hpp
+++ b/nano/node/rocksdb/rocksdb_iterator.hpp
@@ -74,7 +74,7 @@ class rocksdb_iterator : public store_iterator_impl<T, U>
 	}
 
 	rocksdb_iterator (rocksdb::DB * db, nano::transaction const & transaction_a, rocksdb::ColumnFamilyHandle * handle_a) :
-	rocksdb_iterator (db, transaction_a, handle_a, nullptr)
+		rocksdb_iterator (db, transaction_a, handle_a, nullptr)
 	{
 	}
 
diff --git a/nano/node/rocksdb/rocksdb_txn.cpp b/nano/node/rocksdb/rocksdb_txn.cpp
index e3ab6f1582..f80cd93f65 100644
--- a/nano/node/rocksdb/rocksdb_txn.cpp
+++ b/nano/node/rocksdb/rocksdb_txn.cpp
@@ -1,7 +1,7 @@
 #include <nano/node/rocksdb/rocksdb_txn.hpp>
 
 nano::read_rocksdb_txn::read_rocksdb_txn (rocksdb::DB * db_a) :
-db (db_a)
+	db (db_a)
 {
 	if (db_a)
 	{
@@ -33,10 +33,10 @@ void * nano::read_rocksdb_txn::get_handle () const
 }
 
 nano::write_rocksdb_txn::write_rocksdb_txn (rocksdb::OptimisticTransactionDB * db_a, std::vector<nano::tables> const & tables_requiring_locks_a, std::vector<nano::tables> const & tables_no_locks_a, std::unordered_map<nano::tables, nano::mutex> & mutexes_a) :
-db (db_a),
-tables_requiring_locks (tables_requiring_locks_a),
-tables_no_locks (tables_no_locks_a),
-mutexes (mutexes_a)
+	db (db_a),
+	tables_requiring_locks (tables_requiring_locks_a),
+	tables_no_locks (tables_no_locks_a),
+	mutexes (mutexes_a)
 {
 	lock ();
 	rocksdb::OptimisticTransactionOptions txn_options;
diff --git a/nano/node/signatures.cpp b/nano/node/signatures.cpp
index edbf2cb4f8..a8b21fa771 100644
--- a/nano/node/signatures.cpp
+++ b/nano/node/signatures.cpp
@@ -4,7 +4,7 @@
 #include <nano/node/signatures.hpp>
 
 nano::signature_checker::signature_checker (unsigned num_threads) :
-thread_pool (num_threads, nano::thread_role::name::signature_checking)
+	thread_pool (num_threads, nano::thread_role::name::signature_checking)
 {
 }
 
@@ -89,7 +89,7 @@ void nano::signature_checker::flush ()
 bool nano::signature_checker::verify_batch (const nano::signature_check_set & check_a, size_t start_index, size_t size)
 {
 	nano::validate_message_batch (check_a.messages + start_index, check_a.message_lengths + start_index, check_a.pub_keys + start_index, check_a.signatures + start_index, size, check_a.verifications + start_index);
-	return std::all_of (check_a.verifications + start_index, check_a.verifications + start_index + size, [](int verification) { return verification == 0 || verification == 1; });
+	return std::all_of (check_a.verifications + start_index, check_a.verifications + start_index + size, [] (int verification) { return verification == 0 || verification == 1; });
 }
 
 /* This operates on a number of signatures of size (num_batches * batch_size) from the beginning of the check_a pointers.
diff --git a/nano/node/signatures.hpp b/nano/node/signatures.hpp
index 94cb347cbf..5cda22c7e7 100644
--- a/nano/node/signatures.hpp
+++ b/nano/node/signatures.hpp
@@ -13,7 +13,7 @@ class signature_check_set final
 {
 public:
 	signature_check_set (size_t size, unsigned char const ** messages, size_t * message_lengths, unsigned char const ** pub_keys, unsigned char const ** signatures, int * verifications) :
-	size (size), messages (messages), message_lengths (message_lengths), pub_keys (pub_keys), signatures (signatures), verifications (verifications)
+		size (size), messages (messages), message_lengths (message_lengths), pub_keys (pub_keys), signatures (signatures), verifications (verifications)
 	{
 	}
 
@@ -45,7 +45,7 @@ class signature_checker final
 	struct Task final
 	{
 		Task (nano::signature_check_set & check, size_t pending) :
-		check (check), pending (pending)
+			check (check), pending (pending)
 		{
 		}
 		~Task ()
diff --git a/nano/node/socket.cpp b/nano/node/socket.cpp
index 4ddf865fe7..fe2b6760ee 100644
--- a/nano/node/socket.cpp
+++ b/nano/node/socket.cpp
@@ -9,12 +9,12 @@
 #include <limits>
 
 nano::socket::socket (nano::node & node_a, boost::optional<std::chrono::seconds> io_timeout_a) :
-strand{ node_a.io_ctx.get_executor () },
-tcp_socket{ node_a.io_ctx },
-node{ node_a },
-next_deadline{ std::numeric_limits<uint64_t>::max () },
-last_completion_time{ 0 },
-io_timeout{ io_timeout_a }
+	strand{ node_a.io_ctx.get_executor () },
+	tcp_socket{ node_a.io_ctx },
+	node{ node_a },
+	next_deadline{ std::numeric_limits<uint64_t>::max () },
+	last_completion_time{ 0 },
+	io_timeout{ io_timeout_a }
 {
 	if (!io_timeout)
 	{
@@ -27,21 +27,21 @@ nano::socket::~socket ()
 	close_internal ();
 }
 
-void nano::socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::function<void(boost::system::error_code const &)> callback_a)
+void nano::socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::function<void (boost::system::error_code const &)> callback_a)
 {
 	checkup ();
 	auto this_l (shared_from_this ());
 	start_timer ();
 	this_l->tcp_socket.async_connect (endpoint_a,
 	boost::asio::bind_executor (this_l->strand,
-	[this_l, callback_a, endpoint_a](boost::system::error_code const & ec) {
+	[this_l, callback_a, endpoint_a] (boost::system::error_code const & ec) {
 		this_l->stop_timer ();
 		this_l->remote = endpoint_a;
 		callback_a (ec);
 	}));
 }
 
-void nano::socket::async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void(boost::system::error_code const &, size_t)> callback_a)
+void nano::socket::async_read (std::shared_ptr<std::vector<uint8_t>> const & buffer_a, size_t size_a, std::function<void (boost::system::error_code const &, size_t)> callback_a)
 {
 	if (size_a <= buffer_a->size ())
 	{
@@ -49,10 +49,10 @@ void nano::socket::async_read (std::shared_ptr<std::vector<uint8_t>> const & buf
 		if (!closed)
 		{
 			start_timer ();
-			boost::asio::post (strand, boost::asio::bind_executor (strand, [buffer_a, callback_a, size_a, this_l]() {
+			boost::asio::post (strand, boost::asio::bind_executor (strand, [buffer_a, callback_a, size_a, this_l] () {
 				boost::asio::async_read (this_l->tcp_socket, boost::asio::buffer (buffer_a->data (), size_a),
 				boost::asio::bind_executor (this_l->strand,
-				[this_l, buffer_a, callback_a](boost::system::error_code const & ec, size_t size_a) {
+				[this_l, buffer_a, callback_a] (boost::system::error_code const & ec, size_t size_a) {
 					this_l->node.stats.add (nano::stat::type::traffic_tcp, nano::stat::dir::in, size_a);
 					this_l->stop_timer ();
 					callback_a (ec, size_a);
@@ -68,18 +68,18 @@ void nano::socket::async_read (std::shared_ptr<std::vector<uint8_t>> const & buf
 	}
 }
 
-void nano::socket::async_write (nano::shared_const_buffer const & buffer_a, std::function<void(boost::system::error_code const &, size_t)> const & callback_a)
+void nano::socket::async_write (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, size_t)> const & callback_a)
 {
 	if (!closed)
 	{
 		++queue_size;
-		boost::asio::post (strand, boost::asio::bind_executor (strand, [buffer_a, callback_a, this_l = shared_from_this ()]() {
+		boost::asio::post (strand, boost::asio::bind_executor (strand, [buffer_a, callback_a, this_l = shared_from_this ()] () {
 			if (!this_l->closed)
 			{
 				this_l->start_timer ();
 				nano::async_write (this_l->tcp_socket, buffer_a,
 				boost::asio::bind_executor (this_l->strand,
-				[buffer_a, callback_a, this_l](boost::system::error_code ec, std::size_t size_a) {
+				[buffer_a, callback_a, this_l] (boost::system::error_code ec, std::size_t size_a) {
 					--this_l->queue_size;
 					this_l->node.stats.add (nano::stat::type::traffic_tcp, nano::stat::dir::out, size_a);
 					this_l->stop_timer ();
@@ -100,7 +100,7 @@ void nano::socket::async_write (nano::shared_const_buffer const & buffer_a, std:
 	}
 	else if (callback_a)
 	{
-		node.background ([callback_a]() {
+		node.background ([callback_a] () {
 			callback_a (boost::system::errc::make_error_code (boost::system::errc::not_supported), 0);
 		});
 	}
@@ -124,7 +124,7 @@ void nano::socket::stop_timer ()
 void nano::socket::checkup ()
 {
 	std::weak_ptr<nano::socket> this_w (shared_from_this ());
-	node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (node.network_params.network.is_dev_network () ? 1 : 2), [this_w]() {
+	node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (node.network_params.network.is_dev_network () ? 1 : 2), [this_w] () {
 		if (auto this_l = this_w.lock ())
 		{
 			uint64_t now (nano::seconds_since_epoch ());
@@ -159,7 +159,7 @@ bool nano::socket::has_timed_out () const
 void nano::socket::set_timeout (std::chrono::seconds io_timeout_a)
 {
 	auto this_l (shared_from_this ());
-	boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l, io_timeout_a]() {
+	boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l, io_timeout_a] () {
 		this_l->io_timeout = io_timeout_a;
 	}));
 }
@@ -197,10 +197,10 @@ nano::tcp_endpoint nano::socket::remote_endpoint () const
 }
 
 nano::server_socket::server_socket (nano::node & node_a, boost::asio::ip::tcp::endpoint local_a, size_t max_connections_a) :
-socket{ node_a, std::chrono::seconds::max () },
-acceptor{ node_a.io_ctx },
-local{ local_a },
-max_inbound_connections{ max_connections_a }
+	socket{ node_a, std::chrono::seconds::max () },
+	acceptor{ node_a.io_ctx },
+	local{ local_a },
+	max_inbound_connections{ max_connections_a }
 {
 }
 
@@ -219,7 +219,7 @@ void nano::server_socket::close ()
 {
 	auto this_l (std::static_pointer_cast<nano::server_socket> (shared_from_this ()));
 
-	boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l]() {
+	boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l] () {
 		this_l->close_internal ();
 		this_l->acceptor.close ();
 		for (auto & connection_w : this_l->connections)
@@ -233,11 +233,11 @@ void nano::server_socket::close ()
 	}));
 }
 
-void nano::server_socket::on_connection (std::function<bool(std::shared_ptr<nano::socket> const &, boost::system::error_code const &)> callback_a)
+void nano::server_socket::on_connection (std::function<bool (std::shared_ptr<nano::socket> const &, boost::system::error_code const &)> callback_a)
 {
 	auto this_l (std::static_pointer_cast<nano::server_socket> (shared_from_this ()));
 
-	boost::asio::post (strand, boost::asio::bind_executor (strand, [this_l, callback_a]() {
+	boost::asio::post (strand, boost::asio::bind_executor (strand, [this_l, callback_a] () {
 		if (this_l->acceptor.is_open ())
 		{
 			if (this_l->connections.size () < this_l->max_inbound_connections)
@@ -246,7 +246,7 @@ void nano::server_socket::on_connection (std::function<bool(std::shared_ptr<nano
 				auto new_connection = std::make_shared<nano::socket> (this_l->node, boost::none);
 				this_l->acceptor.async_accept (new_connection->tcp_socket, new_connection->remote,
 				boost::asio::bind_executor (this_l->strand,
-				[this_l, new_connection, callback_a](boost::system::error_code const & ec_a) {
+				[this_l, new_connection, callback_a] (boost::system::error_code const & ec_a) {
 					this_l->evict_dead_connections ();
 					if (this_l->connections.size () < this_l->max_inbound_connections)
 					{
@@ -277,7 +277,7 @@ void nano::server_socket::on_connection (std::function<bool(std::shared_ptr<nano
 					else
 					{
 						this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_accept_failure, nano::stat::dir::in);
-						boost::asio::post (this_l->strand, boost::asio::bind_executor (this_l->strand, [this_l, callback_a]() {
+						boost::asio::post (this_l->strand, boost::asio::bind_executor (this_l->strand, [this_l, callback_a] () {
 							this_l->on_connection (callback_a);
 						}));
 					}
@@ -291,5 +291,5 @@ void nano::server_socket::on_connection (std::function<bool(std::shared_ptr<nano
 void nano::server_socket::evict_dead_connections ()
 {
 	debug_assert (strand.running_in_this_thread ());
-	connections.erase (std::remove_if (connections.begin (), connections.end (), [](auto & connection) { return connection.expired (); }), connections.end ());
+	connections.erase (std::remove_if (connections.begin (), connections.end (), [] (auto & connection) { return connection.expired (); }), connections.end ());
 }
diff --git a/nano/node/socket.hpp b/nano/node/socket.hpp
index 970704b907..e2002c6790 100644
--- a/nano/node/socket.hpp
+++ b/nano/node/socket.hpp
@@ -41,9 +41,9 @@ class socket : public std::enable_shared_from_this<nano::socket>
 	 */
 	explicit socket (nano::node & node, boost::optional<std::chrono::seconds> io_timeout = boost::none);
 	virtual ~socket ();
-	void async_connect (boost::asio::ip::tcp::endpoint const &, std::function<void(boost::system::error_code const &)>);
-	void async_read (std::shared_ptr<std::vector<uint8_t>> const &, size_t, std::function<void(boost::system::error_code const &, size_t)>);
-	void async_write (nano::shared_const_buffer const &, std::function<void(boost::system::error_code const &, size_t)> const & = nullptr);
+	void async_connect (boost::asio::ip::tcp::endpoint const &, std::function<void (boost::system::error_code const &)>);
+	void async_read (std::shared_ptr<std::vector<uint8_t>> const &, size_t, std::function<void (boost::system::error_code const &, size_t)>);
+	void async_write (nano::shared_const_buffer const &, std::function<void (boost::system::error_code const &, size_t)> const & = nullptr);
 
 	void close ();
 	boost::asio::ip::tcp::endpoint remote_endpoint () const;
@@ -67,7 +67,7 @@ class socket : public std::enable_shared_from_this<nano::socket>
 	{
 	public:
 		nano::shared_const_buffer buffer;
-		std::function<void(boost::system::error_code const &, size_t)> callback;
+		std::function<void (boost::system::error_code const &, size_t)> callback;
 	};
 
 	boost::asio::strand<boost::asio::io_context::executor_type> strand;
@@ -112,7 +112,7 @@ class server_socket final : public socket
 	/** Stop accepting new connections */
 	void close ();
 	/** Register callback for new connections. The callback must return true to keep accepting new connections. */
-	void on_connection (std::function<bool(std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const &)>);
+	void on_connection (std::function<bool (std::shared_ptr<nano::socket> const & new_connection, boost::system::error_code const &)>);
 	uint16_t listening_port ()
 	{
 		return local.port ();
diff --git a/nano/node/state_block_signature_verification.cpp b/nano/node/state_block_signature_verification.cpp
index e6ed7f854c..6e14dd0584 100644
--- a/nano/node/state_block_signature_verification.cpp
+++ b/nano/node/state_block_signature_verification.cpp
@@ -10,14 +10,14 @@
 #include <boost/format.hpp>
 
 nano::state_block_signature_verification::state_block_signature_verification (nano::signature_checker & signature_checker, nano::epochs & epochs, nano::node_config & node_config, nano::logger_mt & logger, uint64_t state_block_signature_verification_size) :
-signature_checker (signature_checker),
-epochs (epochs),
-node_config (node_config),
-logger (logger),
-thread ([this, state_block_signature_verification_size]() {
-	nano::thread_role::set (nano::thread_role::name::state_block_signature_verification);
-	this->run (state_block_signature_verification_size);
-})
+	signature_checker (signature_checker),
+	epochs (epochs),
+	node_config (node_config),
+	logger (logger),
+	thread ([this, state_block_signature_verification_size] () {
+		nano::thread_role::set (nano::thread_role::name::state_block_signature_verification);
+		this->run (state_block_signature_verification_size);
+	})
 {
 }
 
diff --git a/nano/node/state_block_signature_verification.hpp b/nano/node/state_block_signature_verification.hpp
index b534d56980..8a486f56db 100644
--- a/nano/node/state_block_signature_verification.hpp
+++ b/nano/node/state_block_signature_verification.hpp
@@ -24,8 +24,8 @@ class state_block_signature_verification
 	void stop ();
 	bool is_active ();
 
-	std::function<void(std::deque<std::pair<nano::unchecked_info, bool>> &, std::vector<int> const &, std::vector<nano::block_hash> const &, std::vector<nano::signature> const &)> blocks_verified_callback;
-	std::function<void()> transition_inactive_callback;
+	std::function<void (std::deque<std::pair<nano::unchecked_info, bool>> &, std::vector<int> const &, std::vector<nano::block_hash> const &, std::vector<nano::signature> const &)> blocks_verified_callback;
+	std::function<void ()> transition_inactive_callback;
 
 private:
 	nano::signature_checker & signature_checker;
diff --git a/nano/node/telemetry.cpp b/nano/node/telemetry.cpp
index 5617aae838..e370e49ac3 100644
--- a/nano/node/telemetry.cpp
+++ b/nano/node/telemetry.cpp
@@ -19,12 +19,12 @@
 using namespace std::chrono_literals;
 
 nano::telemetry::telemetry (nano::network & network_a, nano::thread_pool & workers_a, nano::observer_set<nano::telemetry_data const &, nano::endpoint const &> & observers_a, nano::stat & stats_a, nano::network_params & network_params_a, bool disable_ongoing_requests_a) :
-network (network_a),
-workers (workers_a),
-observers (observers_a),
-stats (stats_a),
-network_params (network_params_a),
-disable_ongoing_requests (disable_ongoing_requests_a)
+	network (network_a),
+	workers (workers_a),
+	observers (observers_a),
+	stats (stats_a),
+	network_params (network_params_a),
+	disable_ongoing_requests (disable_ongoing_requests_a)
 {
 }
 
@@ -56,7 +56,7 @@ void nano::telemetry::set (nano::telemetry_ack const & message_a, nano::transpor
 			return;
 		}
 
-		recent_or_initial_request_telemetry_data.modify (it, [&message_a](nano::telemetry_info & telemetry_info_a) {
+		recent_or_initial_request_telemetry_data.modify (it, [&message_a] (nano::telemetry_info & telemetry_info_a) {
 			telemetry_info_a.data = message_a.data;
 		});
 
@@ -140,7 +140,7 @@ bool nano::telemetry::within_cache_cutoff (telemetry_info const & telemetry_info
 
 void nano::telemetry::ongoing_req_all_peers (std::chrono::milliseconds next_request_interval)
 {
-	workers.add_timed_task (std::chrono::steady_clock::now () + next_request_interval, [this_w = std::weak_ptr<telemetry> (shared_from_this ())]() {
+	workers.add_timed_task (std::chrono::steady_clock::now () + next_request_interval, [this_w = std::weak_ptr<telemetry> (shared_from_this ())] () {
 		if (auto this_l = this_w.lock ())
 		{
 			// Check if there are any peers which are in the peers list which haven't been request, or any which are below or equal to the cache cutoff time
@@ -154,7 +154,7 @@ void nano::telemetry::ongoing_req_all_peers (std::chrono::milliseconds next_requ
 				{
 					std::shared_ptr<nano::transport::channel> channel;
 					channel_wrapper (std::shared_ptr<nano::transport::channel> const & channel_a) :
-					channel (channel_a)
+						channel (channel_a)
 					{
 					}
 					nano::endpoint endpoint () const
@@ -212,7 +212,7 @@ void nano::telemetry::ongoing_req_all_peers (std::chrono::milliseconds next_requ
 				// Request data from new peers, or ones which are out of date
 				for (auto const & peer : boost::make_iterator_range (peers))
 				{
-					this_l->get_metrics_single_peer_async (peer.channel, [](auto const &) {
+					this_l->get_metrics_single_peer_async (peer.channel, [] (auto const &) {
 						// Intentionally empty, just using to refresh the cache
 					});
 				}
@@ -260,15 +260,15 @@ std::unordered_map<nano::endpoint, nano::telemetry_data> nano::telemetry::get_me
 	return telemetry_data;
 }
 
-void nano::telemetry::get_metrics_single_peer_async (std::shared_ptr<nano::transport::channel> const & channel_a, std::function<void(telemetry_data_response const &)> const & callback_a)
+void nano::telemetry::get_metrics_single_peer_async (std::shared_ptr<nano::transport::channel> const & channel_a, std::function<void (telemetry_data_response const &)> const & callback_a)
 {
-	auto invoke_callback_with_error = [&callback_a, &workers = this->workers, channel_a]() {
+	auto invoke_callback_with_error = [&callback_a, &workers = this->workers, channel_a] () {
 		nano::endpoint endpoint;
 		if (channel_a)
 		{
 			endpoint = channel_a->get_endpoint ();
 		}
-		workers.push_task ([callback_a, endpoint]() {
+		workers.push_task ([callback_a, endpoint] () {
 			auto const error = true;
 			callback_a ({ nano::telemetry_data{}, endpoint, error });
 		});
@@ -278,9 +278,9 @@ void nano::telemetry::get_metrics_single_peer_async (std::shared_ptr<nano::trans
 	{
 		if (channel_a)
 		{
-			auto add_callback_async = [& workers = this->workers, &callback_a](telemetry_data const & telemetry_data_a, nano::endpoint const & endpoint_a) {
+			auto add_callback_async = [&workers = this->workers, &callback_a] (telemetry_data const & telemetry_data_a, nano::endpoint const & endpoint_a) {
 				telemetry_data_response telemetry_data_response_l{ telemetry_data_a, endpoint_a, false };
-				workers.push_task ([telemetry_data_response_l, callback_a]() {
+				workers.push_task ([telemetry_data_response_l, callback_a] () {
 					callback_a (telemetry_data_response_l);
 				});
 			};
@@ -310,7 +310,7 @@ void nano::telemetry::get_metrics_single_peer_async (std::shared_ptr<nano::trans
 					}
 					else
 					{
-						recent_or_initial_request_telemetry_data.modify (it, [](nano::telemetry_info & telemetry_info_a) {
+						recent_or_initial_request_telemetry_data.modify (it, [] (nano::telemetry_info & telemetry_info_a) {
 							telemetry_info_a.undergoing_request = true;
 						});
 					}
@@ -333,7 +333,7 @@ void nano::telemetry::get_metrics_single_peer_async (std::shared_ptr<nano::trans
 nano::telemetry_data_response nano::telemetry::get_metrics_single_peer (std::shared_ptr<nano::transport::channel> const & channel_a)
 {
 	std::promise<telemetry_data_response> promise;
-	get_metrics_single_peer_async (channel_a, [&promise](telemetry_data_response const & single_metric_data_a) {
+	get_metrics_single_peer_async (channel_a, [&promise] (telemetry_data_response const & single_metric_data_a) {
 		promise.set_value (single_metric_data_a);
 	});
 
@@ -345,7 +345,7 @@ void nano::telemetry::fire_request_message (std::shared_ptr<nano::transport::cha
 	uint64_t round_l;
 	{
 		auto it = recent_or_initial_request_telemetry_data.find (channel_a->get_endpoint ());
-		recent_or_initial_request_telemetry_data.modify (it, [](nano::telemetry_info & telemetry_info_a) {
+		recent_or_initial_request_telemetry_data.modify (it, [] (nano::telemetry_info & telemetry_info_a) {
 			++telemetry_info_a.round;
 		});
 		round_l = it->round;
@@ -393,7 +393,7 @@ void nano::telemetry::channel_processed (nano::endpoint const & endpoint_a, bool
 	{
 		if (!error_a)
 		{
-			recent_or_initial_request_telemetry_data.modify (it, [](nano::telemetry_info & telemetry_info_a) {
+			recent_or_initial_request_telemetry_data.modify (it, [] (nano::telemetry_info & telemetry_info_a) {
 				telemetry_info_a.last_response = std::chrono::steady_clock::now ();
 				telemetry_info_a.undergoing_request = false;
 			});
@@ -409,7 +409,7 @@ void nano::telemetry::channel_processed (nano::endpoint const & endpoint_a, bool
 void nano::telemetry::flush_callbacks_async (nano::endpoint const & endpoint_a, bool error_a)
 {
 	// Post to thread_pool so that it's truly async and not on the calling thread (same problem as std::async otherwise)
-	workers.push_task ([endpoint_a, error_a, this_w = std::weak_ptr<nano::telemetry> (shared_from_this ())]() {
+	workers.push_task ([endpoint_a, error_a, this_w = std::weak_ptr<nano::telemetry> (shared_from_this ())] () {
 		if (auto this_l = this_w.lock ())
 		{
 			nano::unique_lock<nano::mutex> lk (this_l->mutex);
@@ -425,7 +425,7 @@ void nano::telemetry::flush_callbacks_async (nano::endpoint const & endpoint_a,
 
 void nano::telemetry::invoke_callbacks (nano::endpoint const & endpoint_a, bool error_a)
 {
-	std::vector<std::function<void(telemetry_data_response const &)>> callbacks_l;
+	std::vector<std::function<void (telemetry_data_response const &)>> callbacks_l;
 	telemetry_data_response response_data{ nano::telemetry_data (), endpoint_a, error_a };
 	{
 		// Copy data so that it can be used outside of holding the lock
@@ -454,10 +454,10 @@ size_t nano::telemetry::telemetry_data_size ()
 }
 
 nano::telemetry_info::telemetry_info (nano::endpoint const & endpoint_a, nano::telemetry_data const & data_a, std::chrono::steady_clock::time_point last_response_a, bool undergoing_request_a) :
-endpoint (endpoint_a),
-data (data_a),
-last_response (last_response_a),
-undergoing_request (undergoing_request_a)
+	endpoint (endpoint_a),
+	data (data_a),
+	last_response (last_response_a),
+	undergoing_request (undergoing_request_a)
 {
 }
 
@@ -472,8 +472,8 @@ std::unique_ptr<nano::container_info_component> nano::collect_container_info (te
 	size_t callbacks_count;
 	{
 		nano::lock_guard<nano::mutex> guard (telemetry.mutex);
-		std::unordered_map<nano::endpoint, std::vector<std::function<void(telemetry_data_response const &)>>> callbacks;
-		callbacks_count = std::accumulate (callbacks.begin (), callbacks.end (), static_cast<size_t> (0), [](auto total, auto const & callback_a) {
+		std::unordered_map<nano::endpoint, std::vector<std::function<void (telemetry_data_response const &)>>> callbacks;
+		callbacks_count = std::accumulate (callbacks.begin (), callbacks.end (), static_cast<size_t> (0), [] (auto total, auto const & callback_a) {
 			return total += callback_a.second.size ();
 		});
 	}
@@ -540,10 +540,10 @@ nano::telemetry_data nano::consolidate_telemetry_data (std::vector<nano::telemet
 	// Remove 10% of the results from the lower and upper bounds to catch any outliers. Need at least 10 responses before any are removed.
 	auto num_either_side_to_remove = telemetry_datas.size () / 10;
 
-	auto strip_outliers_and_sum = [num_either_side_to_remove](auto & counts) {
+	auto strip_outliers_and_sum = [num_either_side_to_remove] (auto & counts) {
 		counts.erase (counts.begin (), std::next (counts.begin (), num_either_side_to_remove));
 		counts.erase (std::next (counts.rbegin (), num_either_side_to_remove).base (), counts.end ());
-		return std::accumulate (counts.begin (), counts.end (), nano::uint128_t (0), [](nano::uint128_t total, auto count) {
+		return std::accumulate (counts.begin (), counts.end (), nano::uint128_t (0), [] (nano::uint128_t total, auto count) {
 			return total += count;
 		});
 	};
@@ -573,8 +573,8 @@ nano::telemetry_data nano::consolidate_telemetry_data (std::vector<nano::telemet
 		consolidated_data.timestamp = std::chrono::system_clock::time_point (std::chrono::milliseconds (boost::numeric_cast<uint64_t> (timestamp_sum / timestamps.size ())));
 	}
 
-	auto set_mode_or_average = [](auto const & collection, auto & var, auto const & sum, size_t size) {
-		auto max = std::max_element (collection.begin (), collection.end (), [](auto const & lhs, auto const & rhs) {
+	auto set_mode_or_average = [] (auto const & collection, auto & var, auto const & sum, size_t size) {
+		auto max = std::max_element (collection.begin (), collection.end (), [] (auto const & lhs, auto const & rhs) {
 			return lhs.second < rhs.second;
 		});
 		if (max->second > 1)
@@ -587,8 +587,8 @@ nano::telemetry_data nano::consolidate_telemetry_data (std::vector<nano::telemet
 		}
 	};
 
-	auto set_mode = [](auto const & collection, auto & var, size_t size) {
-		auto max = std::max_element (collection.begin (), collection.end (), [](auto const & lhs, auto const & rhs) {
+	auto set_mode = [] (auto const & collection, auto & var, size_t size) {
+		auto max = std::max_element (collection.begin (), collection.end (), [] (auto const & lhs, auto const & rhs) {
 			return lhs.second < rhs.second;
 		});
 		if (max->second > 1)
diff --git a/nano/node/telemetry.hpp b/nano/node/telemetry.hpp
index c90809f36a..d965a5be57 100644
--- a/nano/node/telemetry.hpp
+++ b/nano/node/telemetry.hpp
@@ -78,7 +78,7 @@ class telemetry : public std::enable_shared_from_this<telemetry>
 	 * This makes a telemetry request to the specific channel.
 	 * Error is set for: no response received, no payload received, invalid signature or unsound metrics in message (e.g different genesis block) 
 	 */
-	void get_metrics_single_peer_async (std::shared_ptr<nano::transport::channel> const &, std::function<void(telemetry_data_response const &)> const &);
+	void get_metrics_single_peer_async (std::shared_ptr<nano::transport::channel> const &, std::function<void (telemetry_data_response const &)> const &);
 
 	/*
 	 * A blocking version of get_metrics_single_peer_async
@@ -130,7 +130,7 @@ class telemetry : public std::enable_shared_from_this<telemetry>
 	// The maximum time spent waiting for a response to a telemetry request
 	std::chrono::seconds const response_time_cutoff{ network_params.network.is_dev_network () ? (is_sanitizer_build || nano::running_within_valgrind () ? 6 : 3) : 10 };
 
-	std::unordered_map<nano::endpoint, std::vector<std::function<void(telemetry_data_response const &)>>> callbacks;
+	std::unordered_map<nano::endpoint, std::vector<std::function<void (telemetry_data_response const &)>>> callbacks;
 
 	void ongoing_req_all_peers (std::chrono::milliseconds);
 
diff --git a/nano/node/testing.cpp b/nano/node/testing.cpp
index 05aae12fce..78fb6d1e13 100644
--- a/nano/node/testing.cpp
+++ b/nano/node/testing.cpp
@@ -80,7 +80,7 @@ std::shared_ptr<nano::node> nano::system::add_node (nano::node_config const & no
 			}
 		}
 		auto iterations1 (0);
-		while (std::any_of (begin, nodes.end (), [](std::shared_ptr<nano::node> const & node_a) { return node_a->bootstrap_initiator.in_progress (); }))
+		while (std::any_of (begin, nodes.end (), [] (std::shared_ptr<nano::node> const & node_a) { return node_a->bootstrap_initiator.in_progress (); }))
 		{
 			poll ();
 			++iterations1;
@@ -112,7 +112,7 @@ nano::system::system ()
 }
 
 nano::system::system (uint16_t count_a, nano::transport::transport_type type_a, nano::node_flags flags_a) :
-system ()
+	system ()
 {
 	nodes.reserve (count_a);
 	for (uint16_t i (0); i < count_a; ++i)
@@ -184,14 +184,14 @@ std::unique_ptr<nano::state_block> nano::upgrade_epoch (nano::work_pool & pool_a
 	nano::state_block_builder builder;
 	std::error_code ec;
 	auto epoch = builder
-	             .account (dev_genesis_key.pub)
-	             .previous (latest)
-	             .balance (balance)
-	             .link (ledger_a.epoch_link (epoch_a))
-	             .representative (dev_genesis_key.pub)
-	             .sign (dev_genesis_key.prv, dev_genesis_key.pub)
-	             .work (*pool_a.generate (latest, nano::work_threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true))))
-	             .build (ec);
+				 .account (dev_genesis_key.pub)
+				 .previous (latest)
+				 .balance (balance)
+				 .link (ledger_a.epoch_link (epoch_a))
+				 .representative (dev_genesis_key.pub)
+				 .sign (dev_genesis_key.prv, dev_genesis_key.pub)
+				 .work (*pool_a.generate (latest, nano::work_threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true))))
+				 .build (ec);
 
 	bool error{ true };
 	if (!ec && epoch)
@@ -260,7 +260,7 @@ std::error_code nano::system::poll (std::chrono::nanoseconds const & wait_time)
 	return ec;
 }
 
-std::error_code nano::system::poll_until_true (std::chrono::nanoseconds deadline_a, std::function<bool()> predicate_a)
+std::error_code nano::system::poll_until_true (std::chrono::nanoseconds deadline_a, std::function<bool ()> predicate_a)
 {
 	std::error_code ec;
 	deadline_set (deadline_a);
@@ -277,10 +277,10 @@ class traffic_generator : public std::enable_shared_from_this<traffic_generator>
 {
 public:
 	traffic_generator (uint32_t count_a, uint32_t wait_a, std::shared_ptr<nano::node> const & node_a, nano::system & system_a) :
-	count (count_a),
-	wait (wait_a),
-	node (node_a),
-	system (system_a)
+		count (count_a),
+		wait (wait_a),
+		node (node_a),
+		system (system_a)
 	{
 	}
 	void run ()
@@ -291,7 +291,7 @@ class traffic_generator : public std::enable_shared_from_this<traffic_generator>
 		if (count_l > 0)
 		{
 			auto this_l (shared_from_this ());
-			node->workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (wait), [this_l]() { this_l->run (); });
+			node->workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (wait), [this_l] () { this_l->run (); });
 		}
 	}
 	std::vector<nano::account> accounts;
diff --git a/nano/node/testing.hpp b/nano/node/testing.hpp
index bc39e149ec..aefb36e61e 100644
--- a/nano/node/testing.hpp
+++ b/nano/node/testing.hpp
@@ -41,7 +41,7 @@ class system final
 	 * @returns 0 or nano::deadline_expired
 	 */
 	std::error_code poll (const std::chrono::nanoseconds & sleep_time = std::chrono::milliseconds (50));
-	std::error_code poll_until_true (std::chrono::nanoseconds deadline, std::function<bool()>);
+	std::error_code poll_until_true (std::chrono::nanoseconds deadline, std::function<bool ()>);
 	void stop ();
 	void deadline_set (const std::chrono::duration<double, std::nano> & delta);
 	std::shared_ptr<nano::node> add_node (nano::node_flags = nano::node_flags (), nano::transport::transport_type = nano::transport::transport_type::tcp);
diff --git a/nano/node/transport/tcp.cpp b/nano/node/transport/tcp.cpp
index 634d3b2960..8ea2dc67d5 100644
--- a/nano/node/transport/tcp.cpp
+++ b/nano/node/transport/tcp.cpp
@@ -5,8 +5,8 @@
 #include <boost/format.hpp>
 
 nano::transport::channel_tcp::channel_tcp (nano::node & node_a, std::weak_ptr<nano::socket> socket_a) :
-channel (node_a),
-socket (socket_a)
+	channel (node_a),
+	socket (socket_a)
 {
 }
 
@@ -45,14 +45,14 @@ bool nano::transport::channel_tcp::operator== (nano::transport::channel const &
 	return result;
 }
 
-void nano::transport::channel_tcp::send_buffer (nano::shared_const_buffer const & buffer_a, std::function<void(boost::system::error_code const &, size_t)> const & callback_a, nano::buffer_drop_policy policy_a)
+void nano::transport::channel_tcp::send_buffer (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, size_t)> const & callback_a, nano::buffer_drop_policy policy_a)
 {
 	if (auto socket_l = socket.lock ())
 	{
 		if (!socket_l->max () || (policy_a == nano::buffer_drop_policy::no_socket_drop && !socket_l->full ()))
 		{
 			socket_l->async_write (
-			buffer_a, [endpoint_a = socket_l->remote_endpoint (), node = std::weak_ptr<nano::node> (node.shared ()), callback_a](boost::system::error_code const & ec, size_t size_a) {
+			buffer_a, [endpoint_a = socket_l->remote_endpoint (), node = std::weak_ptr<nano::node> (node.shared ()), callback_a] (boost::system::error_code const & ec, size_t size_a) {
 				if (auto node_l = node.lock ())
 				{
 					if (!ec)
@@ -88,7 +88,7 @@ void nano::transport::channel_tcp::send_buffer (nano::shared_const_buffer const
 	}
 	else if (callback_a)
 	{
-		node.background ([callback_a]() {
+		node.background ([callback_a] () {
 			callback_a (boost::system::errc::make_error_code (boost::system::errc::not_supported), 0);
 		});
 	}
@@ -111,7 +111,7 @@ void nano::transport::channel_tcp::set_endpoint ()
 }
 
 nano::transport::tcp_channels::tcp_channels (nano::node & node_a) :
-node (node_a)
+	node (node_a)
 {
 }
 
@@ -221,7 +221,7 @@ bool nano::transport::tcp_channels::store_all (bool clear_peers)
 		nano::lock_guard<nano::mutex> lock (mutex);
 		endpoints.reserve (channels.size ());
 		std::transform (channels.begin (), channels.end (),
-		std::back_inserter (endpoints), [](const auto & channel) { return nano::transport::map_tcp_to_endpoint (channel.endpoint ()); });
+		std::back_inserter (endpoints), [] (const auto & channel) { return nano::transport::map_tcp_to_endpoint (channel.endpoint ()); });
 	}
 	bool result (false);
 	if (!endpoints.empty ())
@@ -263,7 +263,7 @@ nano::tcp_endpoint nano::transport::tcp_channels::bootstrap_peer (uint8_t connec
 		if (i->channel->get_network_version () >= connection_protocol_version_min)
 		{
 			result = i->endpoint ();
-			channels.get<last_bootstrap_attempt_tag> ().modify (i, [](channel_tcp_wrapper & wrapper_a) {
+			channels.get<last_bootstrap_attempt_tag> ().modify (i, [] (channel_tcp_wrapper & wrapper_a) {
 				wrapper_a.channel->set_last_bootstrap_attempt (std::chrono::steady_clock::now ());
 			});
 			i = n;
@@ -430,7 +430,7 @@ void nano::transport::tcp_channels::purge (std::chrono::steady_clock::time_point
 	channels.get<version_tag> ().erase (channels.get<version_tag> ().begin (), lower_bound);
 
 	// Cleanup any sockets which may still be existing from failed node id handshakes
-	node_id_handshake_sockets.erase (std::remove_if (node_id_handshake_sockets.begin (), node_id_handshake_sockets.end (), [this](auto socket) {
+	node_id_handshake_sockets.erase (std::remove_if (node_id_handshake_sockets.begin (), node_id_handshake_sockets.end (), [this] (auto socket) {
 		return channels.get<endpoint_tag> ().find (socket->remote_endpoint ()) == channels.get<endpoint_tag> ().end ();
 	}),
 	node_id_handshake_sockets.end ());
@@ -468,7 +468,7 @@ void nano::transport::tcp_channels::ongoing_keepalive ()
 		}
 	}
 	std::weak_ptr<nano::node> node_w (node.shared ());
-	node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.half_period, [node_w]() {
+	node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.half_period, [node_w] () {
 		if (auto node_l = node_w.lock ())
 		{
 			if (!node_l->network.tcp_channels.stopped)
@@ -499,13 +499,13 @@ void nano::transport::tcp_channels::list (std::deque<std::shared_ptr<nano::trans
 	// clang-format on
 }
 
-void nano::transport::tcp_channels::modify (std::shared_ptr<nano::transport::channel_tcp> const & channel_a, std::function<void(std::shared_ptr<nano::transport::channel_tcp> const &)> modify_callback_a)
+void nano::transport::tcp_channels::modify (std::shared_ptr<nano::transport::channel_tcp> const & channel_a, std::function<void (std::shared_ptr<nano::transport::channel_tcp> const &)> modify_callback_a)
 {
 	nano::lock_guard<nano::mutex> lock (mutex);
 	auto existing (channels.get<endpoint_tag> ().find (channel_a->get_tcp_endpoint ()));
 	if (existing != channels.get<endpoint_tag> ().end ())
 	{
-		channels.get<endpoint_tag> ().modify (existing, [modify_callback_a](channel_tcp_wrapper & wrapper_a) {
+		channels.get<endpoint_tag> ().modify (existing, [modify_callback_a] (channel_tcp_wrapper & wrapper_a) {
 			modify_callback_a (wrapper_a.channel);
 		});
 	}
@@ -517,7 +517,7 @@ void nano::transport::tcp_channels::update (nano::tcp_endpoint const & endpoint_
 	auto existing (channels.get<endpoint_tag> ().find (endpoint_a));
 	if (existing != channels.get<endpoint_tag> ().end ())
 	{
-		channels.get<endpoint_tag> ().modify (existing, [](channel_tcp_wrapper & wrapper_a) {
+		channels.get<endpoint_tag> ().modify (existing, [] (channel_tcp_wrapper & wrapper_a) {
 			wrapper_a.channel->set_last_packet_sent (std::chrono::steady_clock::now ());
 		});
 	}
@@ -545,7 +545,7 @@ void nano::transport::tcp_channels::remove_node_id_handshake_socket (std::shared
 	}
 }
 
-void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a, std::function<void(std::shared_ptr<nano::transport::channel> const &)> const & callback_a)
+void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a, std::function<void (std::shared_ptr<nano::transport::channel> const &)> const & callback_a)
 {
 	if (node.flags.disable_tcp_realtime)
 	{
@@ -557,7 +557,7 @@ void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a
 	auto channel (std::make_shared<nano::transport::channel_tcp> (node, socket_w));
 	std::weak_ptr<nano::node> node_w (node.shared ());
 	socket->async_connect (nano::transport::map_endpoint_to_tcp (endpoint_a),
-	[node_w, channel, socket, endpoint_a, callback_a](boost::system::error_code const & ec) {
+	[node_w, channel, socket, endpoint_a, callback_a] (boost::system::error_code const & ec) {
 		if (auto node_l = node_w.lock ())
 		{
 			if (!ec && channel)
@@ -574,7 +574,7 @@ void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a
 				std::shared_ptr<std::vector<uint8_t>> receive_buffer (std::make_shared<std::vector<uint8_t>> ());
 				receive_buffer->resize (256);
 				node_l->network.tcp_channels.push_node_id_handshake_socket (socket);
-				channel->send_buffer (bytes, [node_w, channel, endpoint_a, receive_buffer, callback_a](boost::system::error_code const & ec, size_t size_a) {
+				channel->send_buffer (bytes, [node_w, channel, endpoint_a, receive_buffer, callback_a] (boost::system::error_code const & ec, size_t size_a) {
 					if (auto node_l = node_w.lock ())
 					{
 						if (!ec && channel)
@@ -605,12 +605,12 @@ void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a
 	});
 }
 
-void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr<nano::transport::channel_tcp> const & channel_a, nano::endpoint const & endpoint_a, std::shared_ptr<std::vector<uint8_t>> const & receive_buffer_a, std::function<void(std::shared_ptr<nano::transport::channel> const &)> const & callback_a)
+void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr<nano::transport::channel_tcp> const & channel_a, nano::endpoint const & endpoint_a, std::shared_ptr<std::vector<uint8_t>> const & receive_buffer_a, std::function<void (std::shared_ptr<nano::transport::channel> const &)> const & callback_a)
 {
 	std::weak_ptr<nano::node> node_w (node.shared ());
 	if (auto socket_l = channel_a->socket.lock ())
 	{
-		auto cleanup_node_id_handshake_socket = [socket_w = channel_a->socket, node_w](nano::endpoint const & endpoint_a, std::function<void(std::shared_ptr<nano::transport::channel>)> const & callback_a) {
+		auto cleanup_node_id_handshake_socket = [socket_w = channel_a->socket, node_w] (nano::endpoint const & endpoint_a, std::function<void (std::shared_ptr<nano::transport::channel>)> const & callback_a) {
 			if (auto node_l = node_w.lock ())
 			{
 				if (auto socket_l = socket_w.lock ())
@@ -621,7 +621,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr<n
 			}
 		};
 
-		auto cleanup_and_udp_fallback = [socket_w = channel_a->socket, node_w, cleanup_node_id_handshake_socket](nano::endpoint const & endpoint_a, std::function<void(std::shared_ptr<nano::transport::channel>)> const & callback_a) {
+		auto cleanup_and_udp_fallback = [socket_w = channel_a->socket, node_w, cleanup_node_id_handshake_socket] (nano::endpoint const & endpoint_a, std::function<void (std::shared_ptr<nano::transport::channel>)> const & callback_a) {
 			if (auto node_l = node_w.lock ())
 			{
 				node_l->network.tcp_channels.udp_fallback (endpoint_a, callback_a);
@@ -629,7 +629,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr<n
 			}
 		};
 
-		socket_l->async_read (receive_buffer_a, 8 + sizeof (nano::account) + sizeof (nano::account) + sizeof (nano::signature), [node_w, channel_a, endpoint_a, receive_buffer_a, callback_a, cleanup_and_udp_fallback, cleanup_node_id_handshake_socket](boost::system::error_code const & ec, size_t size_a) {
+		socket_l->async_read (receive_buffer_a, 8 + sizeof (nano::account) + sizeof (nano::account) + sizeof (nano::signature), [node_w, channel_a, endpoint_a, receive_buffer_a, callback_a, cleanup_and_udp_fallback, cleanup_node_id_handshake_socket] (boost::system::error_code const & ec, size_t size_a) {
 			if (auto node_l = node_w.lock ())
 			{
 				if (!ec && channel_a)
@@ -669,7 +669,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr<n
 									{
 										node_l->logger.try_log (boost::str (boost::format ("Node ID handshake response sent with node ID %1% to %2%: query %3%") % node_l->node_id.pub.to_node_id () % endpoint_a % (*message.query).to_string ()));
 									}
-									channel_a->send_buffer (bytes, [node_w, channel_a, endpoint_a, callback_a, cleanup_and_udp_fallback](boost::system::error_code const & ec, size_t size_a) {
+									channel_a->send_buffer (bytes, [node_w, channel_a, endpoint_a, callback_a, cleanup_and_udp_fallback] (boost::system::error_code const & ec, size_t size_a) {
 										if (auto node_l = node_w.lock ())
 										{
 											if (!ec && channel_a)
@@ -692,7 +692,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr<n
 
 													if (!node_l->flags.disable_initial_telemetry_requests)
 													{
-														node_l->telemetry->get_metrics_single_peer_async (channel_a, [](nano::telemetry_data_response /* unused */) {
+														node_l->telemetry->get_metrics_single_peer_async (channel_a, [] (nano::telemetry_data_response /* unused */) {
 															// Intentionally empty, starts the telemetry request cycle to more quickly disconnect from invalid peers
 														});
 													}
@@ -743,7 +743,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr<n
 	}
 }
 
-void nano::transport::tcp_channels::udp_fallback (nano::endpoint const & endpoint_a, std::function<void(std::shared_ptr<nano::transport::channel> const &)> const & callback_a)
+void nano::transport::tcp_channels::udp_fallback (nano::endpoint const & endpoint_a, std::function<void (std::shared_ptr<nano::transport::channel> const &)> const & callback_a)
 {
 	{
 		nano::lock_guard<nano::mutex> lock (mutex);
diff --git a/nano/node/transport/tcp.hpp b/nano/node/transport/tcp.hpp
index 02318db65d..cb9ff63b6c 100644
--- a/nano/node/transport/tcp.hpp
+++ b/nano/node/transport/tcp.hpp
@@ -39,7 +39,7 @@ namespace transport
 		~channel_tcp ();
 		size_t hash_code () const override;
 		bool operator== (nano::transport::channel const &) const override;
-		void send_buffer (nano::shared_const_buffer const &, std::function<void(boost::system::error_code const &, size_t)> const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override;
+		void send_buffer (nano::shared_const_buffer const &, std::function<void (boost::system::error_code const &, size_t)> const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override;
 		std::string to_string () const override;
 		bool operator== (nano::transport::channel_tcp const & other_a) const
 		{
@@ -102,12 +102,12 @@ namespace transport
 		void ongoing_keepalive ();
 		void list_below_version (std::vector<std::shared_ptr<nano::transport::channel>> &, uint8_t);
 		void list (std::deque<std::shared_ptr<nano::transport::channel>> &, uint8_t = 0, bool = true);
-		void modify (std::shared_ptr<nano::transport::channel_tcp> const &, std::function<void(std::shared_ptr<nano::transport::channel_tcp> const &)>);
+		void modify (std::shared_ptr<nano::transport::channel_tcp> const &, std::function<void (std::shared_ptr<nano::transport::channel_tcp> const &)>);
 		void update (nano::tcp_endpoint const &);
 		// Connection start
-		void start_tcp (nano::endpoint const &, std::function<void(std::shared_ptr<nano::transport::channel> const &)> const & = nullptr);
-		void start_tcp_receive_node_id (std::shared_ptr<nano::transport::channel_tcp> const &, nano::endpoint const &, std::shared_ptr<std::vector<uint8_t>> const &, std::function<void(std::shared_ptr<nano::transport::channel> const &)> const &);
-		void udp_fallback (nano::endpoint const &, std::function<void(std::shared_ptr<nano::transport::channel> const &)> const &);
+		void start_tcp (nano::endpoint const &, std::function<void (std::shared_ptr<nano::transport::channel> const &)> const & = nullptr);
+		void start_tcp_receive_node_id (std::shared_ptr<nano::transport::channel_tcp> const &, nano::endpoint const &, std::shared_ptr<std::vector<uint8_t>> const &, std::function<void (std::shared_ptr<nano::transport::channel> const &)> const &);
+		void udp_fallback (nano::endpoint const &, std::function<void (std::shared_ptr<nano::transport::channel> const &)> const &);
 		void push_node_id_handshake_socket (std::shared_ptr<nano::socket> const & socket_a);
 		void remove_node_id_handshake_socket (std::shared_ptr<nano::socket> const & socket_a);
 		bool node_id_handhake_sockets_empty () const;
@@ -146,7 +146,7 @@ namespace transport
 			std::shared_ptr<nano::socket> socket;
 			std::shared_ptr<nano::bootstrap_server> response_server;
 			channel_tcp_wrapper (std::shared_ptr<nano::transport::channel_tcp> const & channel_a, std::shared_ptr<nano::socket> const & socket_a, std::shared_ptr<nano::bootstrap_server> const & server_a) :
-			channel (channel_a), socket (socket_a), response_server (server_a)
+				channel (channel_a), socket (socket_a), response_server (server_a)
 			{
 			}
 			nano::tcp_endpoint endpoint () const
@@ -184,8 +184,8 @@ namespace transport
 			std::chrono::steady_clock::time_point last_attempt{ std::chrono::steady_clock::now () };
 
 			explicit tcp_endpoint_attempt (nano::tcp_endpoint const & endpoint_a) :
-			endpoint (endpoint_a),
-			address (endpoint_a.address ())
+				endpoint (endpoint_a),
+				address (endpoint_a.address ())
 			{
 			}
 		};
diff --git a/nano/node/transport/transport.cpp b/nano/node/transport/transport.cpp
index 489685959d..5255743648 100644
--- a/nano/node/transport/transport.cpp
+++ b/nano/node/transport/transport.cpp
@@ -80,12 +80,12 @@ nano::tcp_endpoint nano::transport::map_endpoint_to_tcp (nano::endpoint const &
 }
 
 nano::transport::channel::channel (nano::node & node_a) :
-node (node_a)
+	node (node_a)
 {
 	set_network_version (node_a.network_params.protocol.protocol_version);
 }
 
-void nano::transport::channel::send (nano::message const & message_a, std::function<void(boost::system::error_code const &, size_t)> const & callback_a, nano::buffer_drop_policy drop_policy_a)
+void nano::transport::channel::send (nano::message const & message_a, std::function<void (boost::system::error_code const &, size_t)> const & callback_a, nano::buffer_drop_policy drop_policy_a)
 {
 	callback_visitor visitor;
 	message_a.visit (visitor);
@@ -102,7 +102,7 @@ void nano::transport::channel::send (nano::message const & message_a, std::funct
 	{
 		if (callback_a)
 		{
-			node.background ([callback_a]() {
+			node.background ([callback_a] () {
 				callback_a (boost::system::errc::make_error_code (boost::system::errc::not_supported), 0);
 			});
 		}
@@ -117,7 +117,7 @@ void nano::transport::channel::send (nano::message const & message_a, std::funct
 }
 
 nano::transport::channel_loopback::channel_loopback (nano::node & node_a) :
-channel (node_a), endpoint (node_a.network.endpoint ())
+	channel (node_a), endpoint (node_a.network.endpoint ())
 {
 	set_node_id (node_a.node_id.pub);
 	set_network_version (node_a.network_params.protocol.protocol_version);
@@ -134,7 +134,7 @@ bool nano::transport::channel_loopback::operator== (nano::transport::channel con
 	return endpoint == other_a.get_endpoint ();
 }
 
-void nano::transport::channel_loopback::send_buffer (nano::shared_const_buffer const & buffer_a, std::function<void(boost::system::error_code const &, size_t)> const & callback_a, nano::buffer_drop_policy drop_policy_a)
+void nano::transport::channel_loopback::send_buffer (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, size_t)> const & callback_a, nano::buffer_drop_policy drop_policy_a)
 {
 	release_assert (false && "sending to a loopback channel is not supported");
 }
@@ -254,7 +254,7 @@ bool nano::transport::reserved_address (nano::endpoint const & endpoint_a, bool
 using namespace std::chrono_literals;
 
 nano::bandwidth_limiter::bandwidth_limiter (const double limit_burst_ratio_a, const size_t limit_a) :
-bucket (static_cast<size_t> (limit_a * limit_burst_ratio_a), limit_a)
+	bucket (static_cast<size_t> (limit_a * limit_burst_ratio_a), limit_a)
 {
 }
 
diff --git a/nano/node/transport/transport.hpp b/nano/node/transport/transport.hpp
index 09748c3466..cd2e5c5b64 100644
--- a/nano/node/transport/transport.hpp
+++ b/nano/node/transport/transport.hpp
@@ -42,8 +42,8 @@ namespace transport
 		virtual ~channel () = default;
 		virtual size_t hash_code () const = 0;
 		virtual bool operator== (nano::transport::channel const &) const = 0;
-		void send (nano::message const & message_a, std::function<void(boost::system::error_code const &, size_t)> const & callback_a = nullptr, nano::buffer_drop_policy policy_a = nano::buffer_drop_policy::limiter);
-		virtual void send_buffer (nano::shared_const_buffer const &, std::function<void(boost::system::error_code const &, size_t)> const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) = 0;
+		void send (nano::message const & message_a, std::function<void (boost::system::error_code const &, size_t)> const & callback_a = nullptr, nano::buffer_drop_policy policy_a = nano::buffer_drop_policy::limiter);
+		virtual void send_buffer (nano::shared_const_buffer const &, std::function<void (boost::system::error_code const &, size_t)> const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) = 0;
 		virtual std::string to_string () const = 0;
 		virtual nano::endpoint get_endpoint () const = 0;
 		virtual nano::tcp_endpoint get_tcp_endpoint () const = 0;
@@ -139,7 +139,7 @@ namespace transport
 		channel_loopback (nano::node &);
 		size_t hash_code () const override;
 		bool operator== (nano::transport::channel const &) const override;
-		void send_buffer (nano::shared_const_buffer const &, std::function<void(boost::system::error_code const &, size_t)> const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override;
+		void send_buffer (nano::shared_const_buffer const &, std::function<void (boost::system::error_code const &, size_t)> const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override;
 		std::string to_string () const override;
 		bool operator== (nano::transport::channel_loopback const & other_a) const
 		{
diff --git a/nano/node/transport/udp.cpp b/nano/node/transport/udp.cpp
index c2aa0ff6f9..e5d5fc2d65 100644
--- a/nano/node/transport/udp.cpp
+++ b/nano/node/transport/udp.cpp
@@ -8,9 +8,9 @@
 #include <boost/format.hpp>
 
 nano::transport::channel_udp::channel_udp (nano::transport::udp_channels & channels_a, nano::endpoint const & endpoint_a, uint8_t protocol_version_a) :
-channel (channels_a.node),
-endpoint (endpoint_a),
-channels (channels_a)
+	channel (channels_a.node),
+	endpoint (endpoint_a),
+	channels (channels_a)
 {
 	set_network_version (protocol_version_a);
 	debug_assert (endpoint_a.address ().is_v6 ());
@@ -33,10 +33,10 @@ bool nano::transport::channel_udp::operator== (nano::transport::channel const &
 	return result;
 }
 
-void nano::transport::channel_udp::send_buffer (nano::shared_const_buffer const & buffer_a, std::function<void(boost::system::error_code const &, size_t)> const & callback_a, nano::buffer_drop_policy drop_policy_a)
+void nano::transport::channel_udp::send_buffer (nano::shared_const_buffer const & buffer_a, std::function<void (boost::system::error_code const &, size_t)> const & callback_a, nano::buffer_drop_policy drop_policy_a)
 {
 	set_last_packet_sent (std::chrono::steady_clock::now ());
-	channels.send (buffer_a, endpoint, [node = std::weak_ptr<nano::node> (channels.node.shared ()), callback_a](boost::system::error_code const & ec, size_t size_a) {
+	channels.send (buffer_a, endpoint, [node = std::weak_ptr<nano::node> (channels.node.shared ()), callback_a] (boost::system::error_code const & ec, size_t size_a) {
 		if (auto node_l = node.lock ())
 		{
 			if (ec == boost::system::errc::host_unreachable)
@@ -62,8 +62,8 @@ std::string nano::transport::channel_udp::to_string () const
 }
 
 nano::transport::udp_channels::udp_channels (nano::node & node_a, uint16_t port_a) :
-node (node_a),
-strand (node_a.io_ctx.get_executor ())
+	node (node_a),
+	strand (node_a.io_ctx.get_executor ())
 {
 	if (!node.flags.disable_udp)
 	{
@@ -83,10 +83,10 @@ strand (node_a.io_ctx.get_executor ())
 	}
 }
 
-void nano::transport::udp_channels::send (nano::shared_const_buffer const & buffer_a, nano::endpoint endpoint_a, std::function<void(boost::system::error_code const &, size_t)> const & callback_a)
+void nano::transport::udp_channels::send (nano::shared_const_buffer const & buffer_a, nano::endpoint endpoint_a, std::function<void (boost::system::error_code const &, size_t)> const & callback_a)
 {
 	boost::asio::post (strand,
-	[this, buffer_a, endpoint_a, callback_a]() {
+	[this, buffer_a, endpoint_a, callback_a] () {
 		if (!this->stopped)
 		{
 			this->socket->async_send_to (buffer_a, endpoint_a,
@@ -193,7 +193,7 @@ bool nano::transport::udp_channels::store_all (bool clear_peers)
 		nano::lock_guard<nano::mutex> lock (mutex);
 		endpoints.reserve (channels.size ());
 		std::transform (channels.begin (), channels.end (),
-		std::back_inserter (endpoints), [](const auto & channel) { return channel.endpoint (); });
+		std::back_inserter (endpoints), [] (const auto & channel) { return channel.endpoint (); });
 	}
 	bool result (false);
 	if (!endpoints.empty ())
@@ -256,7 +256,7 @@ nano::tcp_endpoint nano::transport::udp_channels::bootstrap_peer (uint8_t connec
 		if (i->channel->get_network_version () >= connection_protocol_version_min)
 		{
 			result = nano::transport::map_endpoint_to_tcp (i->endpoint ());
-			channels.get<last_bootstrap_attempt_tag> ().modify (i, [](channel_udp_wrapper & wrapper_a) {
+			channels.get<last_bootstrap_attempt_tag> ().modify (i, [] (channel_udp_wrapper & wrapper_a) {
 				wrapper_a.channel->set_last_bootstrap_attempt (std::chrono::steady_clock::now ());
 			});
 			i = n;
@@ -283,7 +283,7 @@ void nano::transport::udp_channels::receive ()
 
 		socket->async_receive_from (boost::asio::buffer (data->buffer, nano::network::buffer_size), data->endpoint,
 		boost::asio::bind_executor (strand,
-		[this, data](boost::system::error_code const & error, std::size_t size_a) {
+		[this, data] (boost::system::error_code const & error, std::size_t size_a) {
 			if (!error && !this->stopped)
 			{
 				data->size = size_a;
@@ -302,7 +302,7 @@ void nano::transport::udp_channels::receive ()
 				}
 				if (!this->stopped)
 				{
-					this->node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this]() { this->receive (); });
+					this->node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () { this->receive (); });
 				}
 			}
 		}));
@@ -314,7 +314,7 @@ void nano::transport::udp_channels::start ()
 	debug_assert (!node.flags.disable_udp);
 	for (size_t i = 0; i < node.config.io_threads && !stopped; ++i)
 	{
-		boost::asio::post (strand, [this]() {
+		boost::asio::post (strand, [this] () {
 			receive ();
 		});
 	}
@@ -365,8 +365,8 @@ class udp_message_visitor : public nano::message_visitor
 {
 public:
 	udp_message_visitor (nano::node & node_a, nano::endpoint const & endpoint_a) :
-	node (node_a),
-	endpoint (endpoint_a)
+		node (node_a),
+		endpoint (endpoint_a)
 	{
 	}
 	void keepalive (nano::keepalive const & message_a) override
@@ -437,14 +437,14 @@ class udp_message_visitor : public nano::message_visitor
 			auto cache_exceeded = std::chrono::steady_clock::now () >= find_channel->get_last_telemetry_req () + nano::telemetry_cache_cutoffs::network_to_time (node.network_params.network);
 			if (is_very_first_message || cache_exceeded)
 			{
-				node.network.udp_channels.modify (find_channel, [](std::shared_ptr<nano::transport::channel_udp> const & channel_a) {
+				node.network.udp_channels.modify (find_channel, [] (std::shared_ptr<nano::transport::channel_udp> const & channel_a) {
 					channel_a->set_last_telemetry_req (std::chrono::steady_clock::now ());
 				});
 				message (message_a);
 			}
 			else
 			{
-				node.network.udp_channels.modify (find_channel, [](std::shared_ptr<nano::transport::channel_udp> const & channel_a) {
+				node.network.udp_channels.modify (find_channel, [] (std::shared_ptr<nano::transport::channel_udp> const & channel_a) {
 					channel_a->set_last_packet_received (std::chrono::steady_clock::now ());
 				});
 			}
@@ -478,7 +478,7 @@ class udp_message_visitor : public nano::message_visitor
 					auto new_channel (node.network.udp_channels.insert (endpoint, message_a.header.version_using));
 					if (new_channel)
 					{
-						node.network.udp_channels.modify (new_channel, [&message_a](std::shared_ptr<nano::transport::channel_udp> const & channel_a) {
+						node.network.udp_channels.modify (new_channel, [&message_a] (std::shared_ptr<nano::transport::channel_udp> const & channel_a) {
 							channel_a->set_node_id (message_a.response->first);
 						});
 					}
@@ -509,7 +509,7 @@ class udp_message_visitor : public nano::message_visitor
 		auto find_channel (node.network.udp_channels.channel (endpoint));
 		if (find_channel)
 		{
-			node.network.udp_channels.modify (find_channel, [](std::shared_ptr<nano::transport::channel_udp> const & channel_a) {
+			node.network.udp_channels.modify (find_channel, [] (std::shared_ptr<nano::transport::channel_udp> const & channel_a) {
 				channel_a->set_last_packet_received (std::chrono::steady_clock::now ());
 			});
 			node.network.process_message (message_a, find_channel);
@@ -696,7 +696,7 @@ void nano::transport::udp_channels::ongoing_keepalive ()
 		channel->send (message);
 	}
 	std::weak_ptr<nano::node> node_w (node.shared ());
-	node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.period, [node_w]() {
+	node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.period, [node_w] () {
 		if (auto node_l = node_w.lock ())
 		{
 			node_l->network.udp_channels.ongoing_keepalive ();
@@ -724,13 +724,13 @@ void nano::transport::udp_channels::list (std::deque<std::shared_ptr<nano::trans
 	// clang-format on
 }
 
-void nano::transport::udp_channels::modify (std::shared_ptr<nano::transport::channel_udp> const & channel_a, std::function<void(std::shared_ptr<nano::transport::channel_udp> const &)> modify_callback_a)
+void nano::transport::udp_channels::modify (std::shared_ptr<nano::transport::channel_udp> const & channel_a, std::function<void (std::shared_ptr<nano::transport::channel_udp> const &)> modify_callback_a)
 {
 	nano::lock_guard<nano::mutex> lock (mutex);
 	auto existing (channels.get<endpoint_tag> ().find (channel_a->endpoint));
 	if (existing != channels.get<endpoint_tag> ().end ())
 	{
-		channels.get<endpoint_tag> ().modify (existing, [modify_callback_a](channel_udp_wrapper & wrapper_a) {
+		channels.get<endpoint_tag> ().modify (existing, [modify_callback_a] (channel_udp_wrapper & wrapper_a) {
 			modify_callback_a (wrapper_a.channel);
 		});
 	}
diff --git a/nano/node/transport/udp.hpp b/nano/node/transport/udp.hpp
index 538744ad71..2bf0bc6ff6 100644
--- a/nano/node/transport/udp.hpp
+++ b/nano/node/transport/udp.hpp
@@ -29,7 +29,7 @@ namespace transport
 		channel_udp (nano::transport::udp_channels &, nano::endpoint const &, uint8_t protocol_version);
 		size_t hash_code () const override;
 		bool operator== (nano::transport::channel const &) const override;
-		void send_buffer (nano::shared_const_buffer const &, std::function<void(boost::system::error_code const &, size_t)> const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override;
+		void send_buffer (nano::shared_const_buffer const &, std::function<void (boost::system::error_code const &, size_t)> const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override;
 		std::string to_string () const override;
 		bool operator== (nano::transport::channel_udp const & other_a) const
 		{
@@ -91,7 +91,7 @@ namespace transport
 		void receive ();
 		void start ();
 		void stop ();
-		void send (nano::shared_const_buffer const & buffer_a, nano::endpoint endpoint_a, std::function<void(boost::system::error_code const &, size_t)> const & callback_a);
+		void send (nano::shared_const_buffer const & buffer_a, nano::endpoint endpoint_a, std::function<void (boost::system::error_code const &, size_t)> const & callback_a);
 		nano::endpoint get_local_endpoint () const;
 		void receive_action (nano::message_buffer *);
 		void process_packets ();
@@ -104,7 +104,7 @@ namespace transport
 		void ongoing_keepalive ();
 		void list_below_version (std::vector<std::shared_ptr<nano::transport::channel>> &, uint8_t);
 		void list (std::deque<std::shared_ptr<nano::transport::channel>> &, uint8_t = 0);
-		void modify (std::shared_ptr<nano::transport::channel_udp> const &, std::function<void(std::shared_ptr<nano::transport::channel_udp> const &)>);
+		void modify (std::shared_ptr<nano::transport::channel_udp> const &, std::function<void (std::shared_ptr<nano::transport::channel_udp> const &)>);
 		nano::node & node;
 
 	private:
@@ -135,7 +135,7 @@ namespace transport
 		public:
 			std::shared_ptr<nano::transport::channel_udp> channel;
 			channel_udp_wrapper (std::shared_ptr<nano::transport::channel_udp> const & channel_a) :
-			channel (channel_a)
+				channel (channel_a)
 			{
 			}
 			nano::endpoint endpoint () const
@@ -170,7 +170,7 @@ namespace transport
 			std::chrono::steady_clock::time_point last_attempt{ std::chrono::steady_clock::now () };
 
 			explicit endpoint_attempt (nano::endpoint const & endpoint_a) :
-			endpoint (endpoint_a)
+				endpoint (endpoint_a)
 			{
 			}
 		};
diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp
index bfacd1a2d2..954419dd93 100644
--- a/nano/node/vote_processor.cpp
+++ b/nano/node/vote_processor.cpp
@@ -16,24 +16,24 @@
 #include <boost/format.hpp>
 
 nano::vote_processor::vote_processor (nano::signature_checker & checker_a, nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stat & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::logger_mt & logger_a, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a) :
-checker (checker_a),
-active (active_a),
-observers (observers_a),
-stats (stats_a),
-config (config_a),
-logger (logger_a),
-online_reps (online_reps_a),
-rep_crawler (rep_crawler_a),
-ledger (ledger_a),
-network_params (network_params_a),
-max_votes (flags_a.vote_processor_capacity),
-started (false),
-stopped (false),
-is_active (false),
-thread ([this] () {
-	nano::thread_role::set (nano::thread_role::name::vote_processing);
-	process_loop ();
-})
+	checker (checker_a),
+	active (active_a),
+	observers (observers_a),
+	stats (stats_a),
+	config (config_a),
+	logger (logger_a),
+	online_reps (online_reps_a),
+	rep_crawler (rep_crawler_a),
+	ledger (ledger_a),
+	network_params (network_params_a),
+	max_votes (flags_a.vote_processor_capacity),
+	started (false),
+	stopped (false),
+	is_active (false),
+	thread ([this] () {
+		nano::thread_role::set (nano::thread_role::name::vote_processing);
+		process_loop ();
+	})
 {
 	nano::unique_lock<nano::mutex> lock (mutex);
 	condition.wait (lock, [&started = started] { return started; });
diff --git a/nano/node/voting.cpp b/nano/node/voting.cpp
index 6b229efbf6..9c075f3518 100644
--- a/nano/node/voting.cpp
+++ b/nano/node/voting.cpp
@@ -34,7 +34,7 @@ void nano::vote_spacing::flag (nano::root const & root_a, nano::block_hash const
 	auto existing = recent.get<tag_root> ().find (root_a);
 	if (existing != recent.end ())
 	{
-		recent.get<tag_root> ().modify (existing, [now](entry & entry) {
+		recent.get<tag_root> ().modify (existing, [now] (entry & entry) {
 			entry.time = now;
 		});
 	}
@@ -54,9 +54,9 @@ bool nano::local_vote_history::consistency_check (nano::root const & root_a) con
 	auto & history_by_root (history.get<tag_root> ());
 	auto const range (history_by_root.equal_range (root_a));
 	// All cached votes for a root must be for the same hash, this is actively enforced in local_vote_history::add
-	auto consistent = std::all_of (range.first, range.second, [hash = range.first->hash](auto const & info_a) { return info_a.hash == hash; });
+	auto consistent = std::all_of (range.first, range.second, [hash = range.first->hash] (auto const & info_a) { return info_a.hash == hash; });
 	std::vector<nano::account> accounts;
-	std::transform (range.first, range.second, std::back_inserter (accounts), [](auto const & info_a) { return info_a.vote->account; });
+	std::transform (range.first, range.second, std::back_inserter (accounts), [] (auto const & info_a) { return info_a.vote->account; });
 	std::sort (accounts.begin (), accounts.end ());
 	// All cached votes must be unique by account, this is actively enforced in local_vote_history::add
 	consistent = consistent && accounts.size () == std::unique (accounts.begin (), accounts.end ()) - accounts.begin ();
@@ -100,7 +100,7 @@ std::vector<std::shared_ptr<nano::vote>> nano::local_vote_history::votes (nano::
 	nano::lock_guard<nano::mutex> guard (mutex);
 	std::vector<std::shared_ptr<nano::vote>> result;
 	auto range (history.get<tag_root> ().equal_range (root_a));
-	std::transform (range.first, range.second, std::back_inserter (result), [](auto const & entry) { return entry.vote; });
+	std::transform (range.first, range.second, std::back_inserter (result), [] (auto const & entry) { return entry.vote; });
 	return result;
 }
 
@@ -150,18 +150,18 @@ std::unique_ptr<nano::container_info_component> nano::collect_container_info (na
 }
 
 nano::vote_generator::vote_generator (nano::node_config const & config_a, nano::ledger & ledger_a, nano::wallets & wallets_a, nano::vote_processor & vote_processor_a, nano::local_vote_history & history_a, nano::network & network_a, nano::stat & stats_a) :
-config (config_a),
-ledger (ledger_a),
-wallets (wallets_a),
-vote_processor (vote_processor_a),
-history (history_a),
-spacing{ config_a.network_params.voting.delay },
-network (network_a),
-stats (stats_a),
-thread ([this]() { run (); })
+	config (config_a),
+	ledger (ledger_a),
+	wallets (wallets_a),
+	vote_processor (vote_processor_a),
+	history (history_a),
+	spacing{ config_a.network_params.voting.delay },
+	network (network_a),
+	stats (stats_a),
+	thread ([this] () { run (); })
 {
 	nano::unique_lock<nano::mutex> lock (mutex);
-	condition.wait (lock, [& started = started] { return started; });
+	condition.wait (lock, [&started = started] { return started; });
 }
 
 void nano::vote_generator::add (nano::root const & root_a, nano::block_hash const & hash_a)
@@ -210,10 +210,10 @@ size_t nano::vote_generator::generate (std::vector<std::shared_ptr<nano::block>>
 	request_t::first_type req_candidates;
 	{
 		auto transaction (ledger.store.tx_begin_read ());
-		auto dependents_confirmed = [&transaction, this](auto const & block_a) {
+		auto dependents_confirmed = [&transaction, this] (auto const & block_a) {
 			return this->ledger.dependents_confirmed (transaction, *block_a);
 		};
-		auto as_candidate = [](auto const & block_a) {
+		auto as_candidate = [] (auto const & block_a) {
 			return candidate_t{ block_a->root (), block_a->hash () };
 		};
 		nano::transform_if (blocks_a.begin (), blocks_a.end (), std::back_inserter (req_candidates), dependents_confirmed, as_candidate);
@@ -230,7 +230,7 @@ size_t nano::vote_generator::generate (std::vector<std::shared_ptr<nano::block>>
 	return result;
 }
 
-void nano::vote_generator::set_reply_action (std::function<void(std::shared_ptr<nano::vote> const &, std::shared_ptr<nano::transport::channel> const &)> action_a)
+void nano::vote_generator::set_reply_action (std::function<void (std::shared_ptr<nano::vote> const &, std::shared_ptr<nano::transport::channel> const &)> action_a)
 {
 	release_assert (!reply_action);
 	reply_action = action_a;
@@ -272,7 +272,7 @@ void nano::vote_generator::broadcast (nano::unique_lock<nano::mutex> & lock_a)
 	if (!hashes.empty ())
 	{
 		lock_a.unlock ();
-		vote (hashes, roots, [this](auto const & vote_a) {
+		vote (hashes, roots, [this] (auto const & vote_a) {
 			this->broadcast_action (vote_a);
 			this->stats.inc (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts);
 		});
@@ -321,7 +321,7 @@ void nano::vote_generator::reply (nano::unique_lock<nano::mutex> & lock_a, reque
 		if (!hashes.empty ())
 		{
 			stats.add (nano::stat::type::requests, nano::stat::detail::requests_generated_hashes, stat::dir::in, hashes.size ());
-			vote (hashes, roots, [this, &channel = request_a.second](std::shared_ptr<nano::vote> const & vote_a) {
+			vote (hashes, roots, [this, &channel = request_a.second] (std::shared_ptr<nano::vote> const & vote_a) {
 				this->reply_action (vote_a, channel);
 				this->stats.inc (nano::stat::type::requests, nano::stat::detail::requests_generated_votes, stat::dir::in);
 			});
@@ -331,11 +331,11 @@ void nano::vote_generator::reply (nano::unique_lock<nano::mutex> & lock_a, reque
 	lock_a.lock ();
 }
 
-void nano::vote_generator::vote (std::vector<nano::block_hash> const & hashes_a, std::vector<nano::root> const & roots_a, std::function<void(std::shared_ptr<nano::vote> const &)> const & action_a)
+void nano::vote_generator::vote (std::vector<nano::block_hash> const & hashes_a, std::vector<nano::root> const & roots_a, std::function<void (std::shared_ptr<nano::vote> const &)> const & action_a)
 {
 	debug_assert (hashes_a.size () == roots_a.size ());
 	std::vector<std::shared_ptr<nano::vote>> votes_l;
-	wallets.foreach_representative ([this, &hashes_a, &votes_l](nano::public_key const & pub_a, nano::raw_key const & prv_a) {
+	wallets.foreach_representative ([this, &hashes_a, &votes_l] (nano::public_key const & pub_a, nano::raw_key const & prv_a) {
 		votes_l.emplace_back (std::make_shared<nano::vote> (pub_a, prv_a, nano::milliseconds_since_epoch (), hashes_a));
 	});
 	for (auto const & vote_l : votes_l)
@@ -378,10 +378,10 @@ void nano::vote_generator::run ()
 		}
 		else
 		{
-			condition.wait_for (lock, config.vote_generator_delay, [this]() { return this->candidates.size () >= nano::network::confirm_ack_hashes_max; });
+			condition.wait_for (lock, config.vote_generator_delay, [this] () { return this->candidates.size () >= nano::network::confirm_ack_hashes_max; });
 			if (candidates.size () >= config.vote_generator_threshold && candidates.size () < nano::network::confirm_ack_hashes_max)
 			{
-				condition.wait_for (lock, config.vote_generator_delay, [this]() { return this->candidates.size () >= nano::network::confirm_ack_hashes_max; });
+				condition.wait_for (lock, config.vote_generator_delay, [this] () { return this->candidates.size () >= nano::network::confirm_ack_hashes_max; });
 			}
 			if (!candidates.empty ())
 			{
@@ -392,7 +392,7 @@ void nano::vote_generator::run ()
 }
 
 nano::vote_generator_session::vote_generator_session (nano::vote_generator & vote_generator_a) :
-generator (vote_generator_a)
+	generator (vote_generator_a)
 {
 }
 
diff --git a/nano/node/voting.hpp b/nano/node/voting.hpp
index 074b26ab69..32a83d21cc 100644
--- a/nano/node/voting.hpp
+++ b/nano/node/voting.hpp
@@ -7,8 +7,8 @@
 #include <nano/secure/common.hpp>
 
 #include <boost/multi_index/hashed_index.hpp>
-#include <boost/multi_index/ordered_index.hpp>
 #include <boost/multi_index/member.hpp>
+#include <boost/multi_index/ordered_index.hpp>
 #include <boost/multi_index/sequenced_index.hpp>
 #include <boost/multi_index_container.hpp>
 
@@ -41,20 +41,22 @@ class vote_spacing final
 		std::chrono::steady_clock::time_point time;
 		nano::block_hash hash;
 	};
-	
+
 	boost::multi_index_container<entry,
 	mi::indexed_by<
-		mi::hashed_non_unique<mi::tag<class tag_root>,
-			mi::member<entry, nano::root, &entry::root>>,
-		mi::ordered_non_unique<mi::tag<class tag_time>,
-			mi::member<entry, std::chrono::steady_clock::time_point, &entry::time>>
-	>>
+	mi::hashed_non_unique<mi::tag<class tag_root>,
+	mi::member<entry, nano::root, &entry::root>>,
+	mi::ordered_non_unique<mi::tag<class tag_time>,
+	mi::member<entry, std::chrono::steady_clock::time_point, &entry::time>>>>
 	recent;
 	std::chrono::milliseconds const delay;
 	void trim ();
+
 public:
 	vote_spacing (std::chrono::milliseconds const & delay) :
-	delay{ delay } {}
+		delay{ delay }
+	{
+	}
 	bool votable (nano::root const & root_a, nano::block_hash const & hash_a) const;
 	void flag (nano::root const & root_a, nano::block_hash const & hash_a);
 	size_t size () const;
@@ -66,9 +68,9 @@ class local_vote_history final
 	{
 	public:
 		local_vote (nano::root const & root_a, nano::block_hash const & hash_a, std::shared_ptr<nano::vote> const & vote_a) :
-		root (root_a),
-		hash (hash_a),
-		vote (vote_a)
+			root (root_a),
+			hash (hash_a),
+			vote (vote_a)
 		{
 		}
 		nano::root root;
@@ -78,7 +80,7 @@ class local_vote_history final
 
 public:
 	local_vote_history (nano::voting_constants const & constants) :
-	constants{ constants }
+		constants{ constants }
 	{
 	}
 	void add (nano::root const & root_a, nano::block_hash const & hash_a, std::shared_ptr<nano::vote> const & vote_a);
@@ -123,16 +125,16 @@ class vote_generator final
 	void add (nano::root const &, nano::block_hash const &);
 	/** Queue blocks for vote generation, returning the number of successful candidates.*/
 	size_t generate (std::vector<std::shared_ptr<nano::block>> const & blocks_a, std::shared_ptr<nano::transport::channel> const & channel_a);
-	void set_reply_action (std::function<void(std::shared_ptr<nano::vote> const &, std::shared_ptr<nano::transport::channel> const &)>);
+	void set_reply_action (std::function<void (std::shared_ptr<nano::vote> const &, std::shared_ptr<nano::transport::channel> const &)>);
 	void stop ();
 
 private:
 	void run ();
 	void broadcast (nano::unique_lock<nano::mutex> &);
 	void reply (nano::unique_lock<nano::mutex> &, request_t &&);
-	void vote (std::vector<nano::block_hash> const &, std::vector<nano::root> const &, std::function<void(std::shared_ptr<nano::vote> const &)> const &);
+	void vote (std::vector<nano::block_hash> const &, std::vector<nano::root> const &, std::function<void (std::shared_ptr<nano::vote> const &)> const &);
 	void broadcast_action (std::shared_ptr<nano::vote> const &) const;
-	std::function<void(std::shared_ptr<nano::vote> const &, std::shared_ptr<nano::transport::channel> &)> reply_action; // must be set only during initialization by using set_reply_action
+	std::function<void (std::shared_ptr<nano::vote> const &, std::shared_ptr<nano::transport::channel> &)> reply_action; // must be set only during initialization by using set_reply_action
 	nano::node_config const & config;
 	nano::ledger & ledger;
 	nano::wallets & wallets;
diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp
index 16229c6525..d13cb0454d 100644
--- a/nano/node/wallet.cpp
+++ b/nano/node/wallet.cpp
@@ -254,9 +254,9 @@ size_t const nano::wallet_store::check_iv_index (0);
 size_t const nano::wallet_store::seed_iv_index (1);
 
 nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, nano::transaction & transaction_a, nano::account representative_a, unsigned fanout_a, std::string const & wallet_a, std::string const & json_a) :
-password (0, fanout_a),
-wallet_key_mem (0, fanout_a),
-kdf (kdf_a)
+	password (0, fanout_a),
+	wallet_key_mem (0, fanout_a),
+	kdf (kdf_a)
 {
 	init_a = false;
 	initialize (transaction_a, init_a, wallet_a);
@@ -310,9 +310,9 @@ kdf (kdf_a)
 }
 
 nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, nano::transaction & transaction_a, nano::account representative_a, unsigned fanout_a, std::string const & wallet_a) :
-password (0, fanout_a),
-wallet_key_mem (0, fanout_a),
-kdf (kdf_a)
+	password (0, fanout_a),
+	wallet_key_mem (0, fanout_a),
+	kdf (kdf_a)
 {
 	init_a = false;
 	initialize (transaction_a, init_a, wallet_a);
@@ -654,16 +654,16 @@ void nano::kdf::phs (nano::raw_key & result_a, std::string const & password_a, n
 }
 
 nano::wallet::wallet (bool & init_a, nano::transaction & transaction_a, nano::wallets & wallets_a, std::string const & wallet_a) :
-lock_observer ([] (bool, bool) {}),
-store (init_a, wallets_a.kdf, transaction_a, wallets_a.node.config.random_representative (), wallets_a.node.config.password_fanout, wallet_a),
-wallets (wallets_a)
+	lock_observer ([] (bool, bool) {}),
+	store (init_a, wallets_a.kdf, transaction_a, wallets_a.node.config.random_representative (), wallets_a.node.config.password_fanout, wallet_a),
+	wallets (wallets_a)
 {
 }
 
 nano::wallet::wallet (bool & init_a, nano::transaction & transaction_a, nano::wallets & wallets_a, std::string const & wallet_a, std::string const & json) :
-lock_observer ([] (bool, bool) {}),
-store (init_a, wallets_a.kdf, transaction_a, wallets_a.node.config.random_representative (), wallets_a.node.config.password_fanout, wallet_a, json),
-wallets (wallets_a)
+	lock_observer ([] (bool, bool) {}),
+	store (init_a, wallets_a.kdf, transaction_a, wallets_a.node.config.random_representative (), wallets_a.node.config.password_fanout, wallet_a, json),
+	wallets (wallets_a)
 {
 }
 
@@ -1304,8 +1304,8 @@ void nano::wallet::work_cache_blocking (nano::account const & account_a, nano::r
 }
 
 nano::work_watcher::work_watcher (nano::node & node_a) :
-node (node_a),
-stopped (false)
+	node (node_a),
+	stopped (false)
 {
 	node.observers.blocks.add ([this] (nano::election_status const & status_a, std::vector<nano::vote_with_weight_info> const & votes_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a) {
 		this->remove (*status_a.winner);
@@ -1446,15 +1446,15 @@ void nano::wallets::do_wallet_actions ()
 }
 
 nano::wallets::wallets (bool error_a, nano::node & node_a) :
-observer ([] (bool) {}),
-node (node_a),
-env (boost::polymorphic_downcast<nano::mdb_wallets_store *> (node_a.wallets_store_impl.get ())->environment),
-stopped (false),
-watcher (std::make_shared<nano::work_watcher> (node_a)),
-thread ([this] () {
-	nano::thread_role::set (nano::thread_role::name::wallet_actions);
-	do_wallet_actions ();
-})
+	observer ([] (bool) {}),
+	node (node_a),
+	env (boost::polymorphic_downcast<nano::mdb_wallets_store *> (node_a.wallets_store_impl.get ())->environment),
+	stopped (false),
+	watcher (std::make_shared<nano::work_watcher> (node_a)),
+	thread ([this] () {
+		nano::thread_role::set (nano::thread_role::name::wallet_actions);
+		do_wallet_actions ();
+	})
 {
 	nano::unique_lock<nano::mutex> lock (mutex);
 	if (!error_a)
@@ -1919,7 +1919,7 @@ nano::store_iterator<nano::account, nano::wallet_value> nano::wallet_store::end
 	return nano::store_iterator<nano::account, nano::wallet_value> (nullptr);
 }
 nano::mdb_wallets_store::mdb_wallets_store (boost::filesystem::path const & path_a, nano::lmdb_config const & lmdb_config_a) :
-environment (error, path_a, nano::mdb_env::options::make ().set_config (lmdb_config_a).override_config_sync (nano::lmdb_config::sync_strategy::always).override_config_map_size (1ULL * 1024 * 1024 * 1024))
+	environment (error, path_a, nano::mdb_env::options::make ().set_config (lmdb_config_a).override_config_sync (nano::lmdb_config::sync_strategy::always).override_config_map_size (1ULL * 1024 * 1024 * 1024))
 {
 }
 
diff --git a/nano/node/wallet.hpp b/nano/node/wallet.hpp
index b13660a282..7ff706a675 100644
--- a/nano/node/wallet.hpp
+++ b/nano/node/wallet.hpp
@@ -136,11 +136,11 @@ class wallet final : public std::enable_shared_from_this<nano::wallet>
 	bool import (std::string const &, std::string const &);
 	void serialize (std::string &);
 	bool change_sync (nano::account const &, nano::account const &);
-	void change_async (nano::account const &, nano::account const &, std::function<void(std::shared_ptr<nano::block> const &)> const &, uint64_t = 0, bool = true);
+	void change_async (nano::account const &, nano::account const &, std::function<void (std::shared_ptr<nano::block> const &)> const &, uint64_t = 0, bool = true);
 	bool receive_sync (std::shared_ptr<nano::block> const &, nano::account const &, nano::uint128_t const &);
-	void receive_async (nano::block_hash const &, nano::account const &, nano::uint128_t const &, nano::account const &, std::function<void(std::shared_ptr<nano::block> const &)> const &, uint64_t = 0, bool = true);
+	void receive_async (nano::block_hash const &, nano::account const &, nano::uint128_t const &, nano::account const &, std::function<void (std::shared_ptr<nano::block> const &)> const &, uint64_t = 0, bool = true);
 	nano::block_hash send_sync (nano::account const &, nano::account const &, nano::uint128_t const &);
-	void send_async (nano::account const &, nano::account const &, nano::uint128_t const &, std::function<void(std::shared_ptr<nano::block> const &)> const &, uint64_t = 0, bool = true, boost::optional<std::string> = {});
+	void send_async (nano::account const &, nano::account const &, nano::uint128_t const &, std::function<void (std::shared_ptr<nano::block> const &)> const &, uint64_t = 0, bool = true, boost::optional<std::string> = {});
 	void work_cache_blocking (nano::account const &, nano::root const &);
 	void work_update (nano::transaction const &, nano::account const &, nano::root const &, uint64_t);
 	// Schedule work generation after a few seconds
@@ -154,7 +154,7 @@ class wallet final : public std::enable_shared_from_this<nano::wallet>
 	bool live ();
 	nano::network_params network_params;
 	std::unordered_set<nano::account> free_accounts;
-	std::function<void(bool, bool)> lock_observer;
+	std::function<void (bool, bool)> lock_observer;
 	nano::wallet_store store;
 	nano::wallets & wallets;
 	nano::mutex representatives_mutex;
@@ -221,8 +221,8 @@ class wallets final
 	void destroy (nano::wallet_id const &);
 	void reload ();
 	void do_wallet_actions ();
-	void queue_wallet_action (nano::uint128_t const &, std::shared_ptr<nano::wallet> const &, std::function<void(nano::wallet &)>);
-	void foreach_representative (std::function<void(nano::public_key const &, nano::raw_key const &)> const &);
+	void queue_wallet_action (nano::uint128_t const &, std::shared_ptr<nano::wallet> const &, std::function<void (nano::wallet &)>);
+	void foreach_representative (std::function<void (nano::public_key const &, nano::raw_key const &)> const &);
 	bool exists (nano::transaction const &, nano::account const &);
 	void stop ();
 	void clear_send_ids (nano::transaction const &);
@@ -234,9 +234,9 @@ class wallets final
 	void move_table (std::string const &, MDB_txn *, MDB_txn *);
 	std::unordered_map<nano::wallet_id, std::shared_ptr<nano::wallet>> get_wallets ();
 	nano::network_params network_params;
-	std::function<void(bool)> observer;
+	std::function<void (bool)> observer;
 	std::unordered_map<nano::wallet_id, std::shared_ptr<nano::wallet>> items;
-	std::multimap<nano::uint128_t, std::pair<std::shared_ptr<nano::wallet>, std::function<void(nano::wallet &)>>, std::greater<nano::uint128_t>> actions;
+	std::multimap<nano::uint128_t, std::pair<std::shared_ptr<nano::wallet>, std::function<void (nano::wallet &)>>, std::greater<nano::uint128_t>> actions;
 	nano::locked<std::unordered_map<nano::account, nano::root>> delayed_work;
 	nano::mutex mutex;
 	nano::mutex action_mutex;
diff --git a/nano/node/websocket.cpp b/nano/node/websocket.cpp
index 667884f7e4..f4e0831b9d 100644
--- a/nano/node/websocket.cpp
+++ b/nano/node/websocket.cpp
@@ -13,13 +13,13 @@
 #include <chrono>
 
 nano::websocket::confirmation_options::confirmation_options (nano::wallets & wallets_a) :
-wallets (wallets_a)
+	wallets (wallets_a)
 {
 }
 
 nano::websocket::confirmation_options::confirmation_options (boost::property_tree::ptree const & options_a, nano::wallets & wallets_a, nano::logger_mt & logger_a) :
-wallets (wallets_a),
-logger (logger_a)
+	wallets (wallets_a),
+	logger (logger_a)
 {
 	// Non-account filtering options
 	include_block = options_a.get<bool> ("include_block", true);
@@ -136,7 +136,7 @@ bool nano::websocket::confirmation_options::should_filter (nano::websocket::mess
 
 bool nano::websocket::confirmation_options::update (boost::property_tree::ptree const & options_a)
 {
-	auto update_accounts = [this](boost::property_tree::ptree const & accounts_text_a, bool insert_a) {
+	auto update_accounts = [this] (boost::property_tree::ptree const & accounts_text_a, bool insert_a) {
 		this->has_account_filtering_options = true;
 		for (auto const & account_l : accounts_text_a)
 		{
@@ -232,7 +232,7 @@ bool nano::websocket::vote_options::should_filter (nano::websocket::message cons
 }
 
 nano::websocket::session::session (nano::websocket::listener & listener_a, socket_type socket_a) :
-ws_listener (listener_a), ws (std::move (socket_a)), strand (ws.get_executor ())
+	ws_listener (listener_a), ws (std::move (socket_a)), strand (ws.get_executor ())
 {
 	ws.text (true);
 	ws_listener.get_logger ().try_log ("Websocket: session started");
@@ -252,7 +252,7 @@ nano::websocket::session::~session ()
 void nano::websocket::session::handshake ()
 {
 	auto this_l (shared_from_this ());
-	ws.async_accept ([this_l](boost::system::error_code const & ec) {
+	ws.async_accept ([this_l] (boost::system::error_code const & ec) {
 		if (!ec)
 		{
 			// Start reading incoming messages
@@ -271,7 +271,7 @@ void nano::websocket::session::close ()
 
 	auto this_l (shared_from_this ());
 	boost::asio::dispatch (strand,
-	[this_l]() {
+	[this_l] () {
 		boost::beast::websocket::close_reason reason;
 		reason.code = boost::beast::websocket::close_code::normal;
 		reason.reason = "Shutting down";
@@ -289,7 +289,7 @@ void nano::websocket::session::write (nano::websocket::message message_a)
 		lk.unlock ();
 		auto this_l (shared_from_this ());
 		boost::asio::post (strand,
-		[message_a, this_l]() {
+		[message_a, this_l] () {
 			bool write_in_progress = !this_l->send_queue.empty ();
 			this_l->send_queue.emplace_back (message_a);
 			if (!write_in_progress)
@@ -307,7 +307,7 @@ void nano::websocket::session::write_queued_messages ()
 
 	ws.async_write (nano::shared_const_buffer (msg),
 	boost::asio::bind_executor (strand,
-	[this_l](boost::system::error_code ec, std::size_t bytes_transferred) {
+	[this_l] (boost::system::error_code ec, std::size_t bytes_transferred) {
 		this_l->send_queue.pop_front ();
 		if (!ec)
 		{
@@ -323,10 +323,10 @@ void nano::websocket::session::read ()
 {
 	auto this_l (shared_from_this ());
 
-	boost::asio::post (strand, [this_l]() {
+	boost::asio::post (strand, [this_l] () {
 		this_l->ws.async_read (this_l->read_buffer,
 		boost::asio::bind_executor (this_l->strand,
-		[this_l](boost::system::error_code ec, std::size_t bytes_transferred) {
+		[this_l] (boost::system::error_code ec, std::size_t bytes_transferred) {
 			if (!ec)
 			{
 				std::stringstream os;
@@ -549,10 +549,10 @@ void nano::websocket::listener::stop ()
 }
 
 nano::websocket::listener::listener (nano::logger_mt & logger_a, nano::wallets & wallets_a, boost::asio::io_context & io_ctx_a, boost::asio::ip::tcp::endpoint endpoint_a) :
-logger (logger_a),
-wallets (wallets_a),
-acceptor (io_ctx_a),
-socket (io_ctx_a)
+	logger (logger_a),
+	wallets (wallets_a),
+	acceptor (io_ctx_a),
+	socket (io_ctx_a)
 {
 	try
 	{
@@ -583,7 +583,7 @@ void nano::websocket::listener::accept ()
 {
 	auto this_l (shared_from_this ());
 	acceptor.async_accept (socket,
-	[this_l](boost::system::error_code const & ec) {
+	[this_l] (boost::system::error_code const & ec) {
 		this_l->on_accept (ec);
 	});
 }
@@ -601,7 +601,7 @@ void nano::websocket::listener::on_accept (boost::system::error_code ec)
 		sessions_mutex.lock ();
 		sessions.push_back (session);
 		// Clean up expired sessions
-		sessions.erase (std::remove_if (sessions.begin (), sessions.end (), [](auto & elem) { return elem.expired (); }), sessions.end ());
+		sessions.erase (std::remove_if (sessions.begin (), sessions.end (), [] (auto & elem) { return elem.expired (); }), sessions.end ());
 		sessions_mutex.unlock ();
 		session->handshake ();
 	}
diff --git a/nano/node/websocket.hpp b/nano/node/websocket.hpp
index 044ddc99b8..a2084c7da0 100644
--- a/nano/node/websocket.hpp
+++ b/nano/node/websocket.hpp
@@ -75,11 +75,11 @@ namespace websocket
 	{
 	public:
 		message (nano::websocket::topic topic_a) :
-		topic (topic_a)
+			topic (topic_a)
 		{
 		}
 		message (nano::websocket::topic topic_a, boost::property_tree::ptree & tree_a) :
-		topic (topic_a), contents (tree_a)
+			topic (topic_a), contents (tree_a)
 		{
 		}
 
diff --git a/nano/node/websocketconfig.cpp b/nano/node/websocketconfig.cpp
index 6cd91574bd..7d49986d11 100644
--- a/nano/node/websocketconfig.cpp
+++ b/nano/node/websocketconfig.cpp
@@ -4,8 +4,8 @@
 #include <nano/node/websocketconfig.hpp>
 
 nano::websocket::config::config () :
-port (network_constants.default_websocket_port),
-address (boost::asio::ip::address_v6::loopback ().to_string ())
+	port (network_constants.default_websocket_port),
+	address (boost::asio::ip::address_v6::loopback ().to_string ())
 {
 }
 
diff --git a/nano/node/write_database_queue.cpp b/nano/node/write_database_queue.cpp
index 118c2493f6..cf2d30f77a 100644
--- a/nano/node/write_database_queue.cpp
+++ b/nano/node/write_database_queue.cpp
@@ -4,14 +4,14 @@
 
 #include <algorithm>
 
-nano::write_guard::write_guard (std::function<void()> guard_finish_callback_a) :
-guard_finish_callback (guard_finish_callback_a)
+nano::write_guard::write_guard (std::function<void ()> guard_finish_callback_a) :
+	guard_finish_callback (guard_finish_callback_a)
 {
 }
 
 nano::write_guard::write_guard (nano::write_guard && write_guard_a) noexcept :
-guard_finish_callback (std::move (write_guard_a.guard_finish_callback)),
-owns (write_guard_a.owns)
+	guard_finish_callback (std::move (write_guard_a.guard_finish_callback)),
+	owns (write_guard_a.owns)
 {
 	write_guard_a.owns = false;
 	write_guard_a.guard_finish_callback = nullptr;
@@ -51,17 +51,17 @@ void nano::write_guard::release ()
 }
 
 nano::write_database_queue::write_database_queue (bool use_noops_a) :
-guard_finish_callback ([use_noops_a, &queue = queue, &mutex = mutex, &cv = cv]() {
-	if (!use_noops_a)
-	{
+	guard_finish_callback ([use_noops_a, &queue = queue, &mutex = mutex, &cv = cv] () {
+		if (!use_noops_a)
 		{
-			nano::lock_guard<nano::mutex> guard (mutex);
-			queue.pop_front ();
+			{
+				nano::lock_guard<nano::mutex> guard (mutex);
+				queue.pop_front ();
+			}
+			cv.notify_all ();
 		}
-		cv.notify_all ();
-	}
-}),
-use_noops (use_noops_a)
+	}),
+	use_noops (use_noops_a)
 {
 }
 
diff --git a/nano/node/write_database_queue.hpp b/nano/node/write_database_queue.hpp
index acc300188c..cb0bab08db 100644
--- a/nano/node/write_database_queue.hpp
+++ b/nano/node/write_database_queue.hpp
@@ -21,7 +21,7 @@ enum class writer
 class write_guard final
 {
 public:
-	write_guard (std::function<void()> guard_finish_callback_a);
+	write_guard (std::function<void ()> guard_finish_callback_a);
 	void release ();
 	~write_guard ();
 	write_guard (write_guard const &) = delete;
@@ -31,7 +31,7 @@ class write_guard final
 	bool is_owned () const;
 
 private:
-	std::function<void()> guard_finish_callback;
+	std::function<void ()> guard_finish_callback;
 	bool owns{ true };
 };
 
@@ -55,7 +55,7 @@ class write_database_queue final
 	std::deque<nano::writer> queue;
 	nano::mutex mutex;
 	nano::condition_variable cv;
-	std::function<void()> guard_finish_callback;
+	std::function<void ()> guard_finish_callback;
 	bool use_noops;
 };
 }
diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp
index 45d28d2578..067a63ea60 100644
--- a/nano/qt/qt.cpp
+++ b/nano/qt/qt.cpp
@@ -48,26 +48,26 @@ bool nano_qt::eventloop_processor::event (QEvent * event_a)
 	return true;
 }
 
-nano_qt::eventloop_event::eventloop_event (std::function<void()> const & action_a) :
-QEvent (QEvent::Type::User),
-action (action_a)
+nano_qt::eventloop_event::eventloop_event (std::function<void ()> const & action_a) :
+	QEvent (QEvent::Type::User),
+	action (action_a)
 {
 }
 
 nano_qt::self_pane::self_pane (nano_qt::wallet & wallet_a, nano::account const & account_a) :
-window (new QWidget),
-layout (new QVBoxLayout),
-self_layout (new QHBoxLayout),
-self_window (new QWidget),
-your_account_label (new QLabel ("Your Nano account:")),
-account_window (new QWidget),
-account_layout (new QHBoxLayout),
-account_text (new QLineEdit),
-copy_button (new QPushButton ("Copy")),
-balance_window (new QWidget),
-balance_layout (new QHBoxLayout),
-balance_label (new QLabel),
-wallet (wallet_a)
+	window (new QWidget),
+	layout (new QVBoxLayout),
+	self_layout (new QHBoxLayout),
+	self_window (new QWidget),
+	your_account_label (new QLabel ("Your Nano account:")),
+	account_window (new QWidget),
+	account_layout (new QHBoxLayout),
+	account_text (new QLineEdit),
+	copy_button (new QPushButton ("Copy")),
+	balance_window (new QWidget),
+	balance_layout (new QHBoxLayout),
+	balance_label (new QLabel),
+	wallet (wallet_a)
 {
 	your_account_label->setStyleSheet ("font-weight: bold;");
 	std::string network = wallet.node.network_params.network.get_current_network_as_string ();
@@ -99,11 +99,11 @@ wallet (wallet_a)
 	layout->setContentsMargins (5, 5, 5, 5);
 	window->setLayout (layout);
 
-	QObject::connect (copy_button, &QPushButton::clicked, [this]() {
+	QObject::connect (copy_button, &QPushButton::clicked, [this] () {
 		this->wallet.application.clipboard ()->setText (QString (this->wallet.account.to_account ().c_str ()));
 		copy_button->setText ("Copied!");
-		this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (2), [this]() {
-			this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+		this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (2), [this] () {
+			this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 				copy_button->setText ("Copy");
 			}));
 		});
@@ -121,20 +121,20 @@ void nano_qt::self_pane::set_balance_text (std::pair<nano::uint128_t, nano::uint
 }
 
 nano_qt::accounts::accounts (nano_qt::wallet & wallet_a) :
-wallet_balance_label (new QLabel),
-window (new QWidget),
-layout (new QVBoxLayout),
-model (new QStandardItemModel),
-view (new QTableView),
-use_account (new QPushButton ("Use account")),
-create_account (new QPushButton ("Create account")),
-import_wallet (new QPushButton ("Import wallet")),
-backup_seed (new QPushButton ("Copy wallet seed to clipboard")),
-separator (new QFrame),
-account_key_line (new QLineEdit),
-account_key_button (new QPushButton ("Import adhoc key")),
-back (new QPushButton ("Back")),
-wallet (wallet_a)
+	wallet_balance_label (new QLabel),
+	window (new QWidget),
+	layout (new QVBoxLayout),
+	model (new QStandardItemModel),
+	view (new QTableView),
+	use_account (new QPushButton ("Use account")),
+	create_account (new QPushButton ("Create account")),
+	import_wallet (new QPushButton ("Import wallet")),
+	backup_seed (new QPushButton ("Copy wallet seed to clipboard")),
+	separator (new QFrame),
+	account_key_line (new QLineEdit),
+	account_key_button (new QPushButton ("Import adhoc key")),
+	back (new QPushButton ("Back")),
+	wallet (wallet_a)
 {
 	separator->setFrameShape (QFrame::HLine);
 	separator->setFrameShadow (QFrame::Sunken);
@@ -157,7 +157,7 @@ wallet (wallet_a)
 	layout->addWidget (back);
 	window->setLayout (layout);
 
-	QObject::connect (use_account, &QPushButton::released, [this]() {
+	QObject::connect (use_account, &QPushButton::released, [this] () {
 		auto selection (view->selectionModel ()->selection ().indexes ());
 		if (selection.size () == 1)
 		{
@@ -167,7 +167,7 @@ wallet (wallet_a)
 			this->wallet.refresh ();
 		}
 	});
-	QObject::connect (account_key_button, &QPushButton::released, [this]() {
+	QObject::connect (account_key_button, &QPushButton::released, [this] () {
 		QString key_text_wide (account_key_line->text ());
 		std::string key_text (key_text_wide.toLocal8Bit ());
 		nano::raw_key key;
@@ -185,10 +185,10 @@ wallet (wallet_a)
 			show_line_error (*account_key_line);
 		}
 	});
-	QObject::connect (back, &QPushButton::clicked, [this]() {
+	QObject::connect (back, &QPushButton::clicked, [this] () {
 		this->wallet.pop_main_stack ();
 	});
-	QObject::connect (create_account, &QPushButton::released, [this]() {
+	QObject::connect (create_account, &QPushButton::released, [this] () {
 		{
 			auto transaction (this->wallet.wallet_m->wallets.tx_begin_write ());
 			if (this->wallet.wallet_m->store.valid_password (transaction))
@@ -196,8 +196,8 @@ wallet (wallet_a)
 				this->wallet.wallet_m->deterministic_insert (transaction);
 				show_button_success (*create_account);
 				create_account->setText ("New account was created");
-				this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this]() {
-					this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+				this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () {
+					this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 						show_button_ok (*create_account);
 						create_account->setText ("Create account");
 					}));
@@ -207,8 +207,8 @@ wallet (wallet_a)
 			{
 				show_button_error (*create_account);
 				create_account->setText ("Wallet is locked, unlock it to create account");
-				this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this]() {
-					this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+				this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () {
+					this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 						show_button_ok (*create_account);
 						create_account->setText ("Create account");
 					}));
@@ -217,10 +217,10 @@ wallet (wallet_a)
 		}
 		refresh ();
 	});
-	QObject::connect (import_wallet, &QPushButton::released, [this]() {
+	QObject::connect (import_wallet, &QPushButton::released, [this] () {
 		this->wallet.push_main_stack (this->wallet.import.window);
 	});
-	QObject::connect (backup_seed, &QPushButton::released, [this]() {
+	QObject::connect (backup_seed, &QPushButton::released, [this] () {
 		nano::raw_key seed;
 		auto transaction (this->wallet.wallet_m->wallets.tx_begin_read ());
 		if (this->wallet.wallet_m->store.valid_password (transaction))
@@ -229,8 +229,8 @@ wallet (wallet_a)
 			this->wallet.application.clipboard ()->setText (QString (seed.to_string ().c_str ()));
 			show_button_success (*backup_seed);
 			backup_seed->setText ("Seed was copied to clipboard");
-			this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this]() {
-				this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+			this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () {
+				this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 					show_button_ok (*backup_seed);
 					backup_seed->setText ("Copy wallet seed to clipboard");
 				}));
@@ -241,15 +241,15 @@ wallet (wallet_a)
 			this->wallet.application.clipboard ()->setText ("");
 			show_button_error (*backup_seed);
 			backup_seed->setText ("Wallet is locked, unlock it to enable the backup");
-			this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this]() {
-				this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+			this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () {
+				this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 					show_button_ok (*backup_seed);
 					backup_seed->setText ("Copy wallet seed to clipboard");
 				}));
 			});
 		}
 	});
-	QObject::connect (account_key_line, &QLineEdit::textChanged, [this](const QString & value) {
+	QObject::connect (account_key_line, &QLineEdit::textChanged, [this] (const QString & value) {
 		auto pos = account_key_line->cursorPosition ();
 		account_key_line->setText (value.trimmed ());
 		account_key_line->setCursorPosition (pos);
@@ -275,8 +275,8 @@ void nano_qt::accounts::refresh_wallet_balance ()
 		final_text += "\nPending: " + wallet.format_balance (pending);
 	}
 	wallet_balance_label->setText (QString (final_text.c_str ()));
-	this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (60), [this]() {
-		this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+	this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (60), [this] () {
+		this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 			refresh_wallet_balance ();
 		}));
 	});
@@ -321,21 +321,21 @@ void nano_qt::accounts::refresh ()
 }
 
 nano_qt::import::import (nano_qt::wallet & wallet_a) :
-window (new QWidget),
-layout (new QVBoxLayout),
-seed_label (new QLabel ("Seed:")),
-seed (new QLineEdit),
-clear_label (new QLabel ("Modifying seed clears existing keys\nType 'clear keys' below to confirm:")),
-clear_line (new QLineEdit),
-import_seed (new QPushButton ("Import seed")),
-separator (new QFrame),
-filename_label (new QLabel ("Path to file:")),
-filename (new QLineEdit),
-password_label (new QLabel ("Password:")),
-password (new QLineEdit),
-perform (new QPushButton ("Import")),
-back (new QPushButton ("Back")),
-wallet (wallet_a)
+	window (new QWidget),
+	layout (new QVBoxLayout),
+	seed_label (new QLabel ("Seed:")),
+	seed (new QLineEdit),
+	clear_label (new QLabel ("Modifying seed clears existing keys\nType 'clear keys' below to confirm:")),
+	clear_line (new QLineEdit),
+	import_seed (new QPushButton ("Import seed")),
+	separator (new QFrame),
+	filename_label (new QLabel ("Path to file:")),
+	filename (new QLineEdit),
+	password_label (new QLabel ("Password:")),
+	password (new QLineEdit),
+	perform (new QPushButton ("Import")),
+	back (new QPushButton ("Back")),
+	wallet (wallet_a)
 {
 	layout->addWidget (seed_label);
 	layout->addWidget (seed);
@@ -352,7 +352,7 @@ wallet (wallet_a)
 	layout->addStretch ();
 	layout->addWidget (back);
 	window->setLayout (layout);
-	QObject::connect (perform, &QPushButton::released, [this]() {
+	QObject::connect (perform, &QPushButton::released, [this] () {
 		std::ifstream stream;
 		stream.open (filename->text ().toStdString ().c_str ());
 		if (!stream.fail ())
@@ -377,10 +377,10 @@ wallet (wallet_a)
 			show_line_error (*filename);
 		}
 	});
-	QObject::connect (back, &QPushButton::released, [this]() {
+	QObject::connect (back, &QPushButton::released, [this] () {
 		this->wallet.pop_main_stack ();
 	});
-	QObject::connect (import_seed, &QPushButton::released, [this]() {
+	QObject::connect (import_seed, &QPushButton::released, [this] () {
 		if (clear_line->text ().toStdString () == "clear keys")
 		{
 			show_line_ok (*clear_line);
@@ -405,8 +405,8 @@ wallet (wallet_a)
 						show_line_error (*seed);
 						show_button_error (*import_seed);
 						import_seed->setText ("Wallet is locked, unlock it to enable the import");
-						this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (10), [this]() {
-							this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+						this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (10), [this] () {
+							this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 								show_line_ok (*seed);
 								show_button_ok (*import_seed);
 								import_seed->setText ("Import seed");
@@ -422,8 +422,8 @@ wallet (wallet_a)
 					show_button_success (*import_seed);
 					import_seed->setText ("Successful import of seed");
 					this->wallet.refresh ();
-					this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this]() {
-						this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+					this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () {
+						this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 							show_button_ok (*import_seed);
 							import_seed->setText ("Import seed");
 						}));
@@ -442,8 +442,8 @@ wallet (wallet_a)
 				{
 					import_seed->setText ("Incorrect seed. Only HEX characters allowed");
 				}
-				this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this]() {
-					this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+				this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () {
+					this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 						show_button_ok (*import_seed);
 						import_seed->setText ("Import seed");
 					}));
@@ -455,20 +455,20 @@ wallet (wallet_a)
 			show_line_error (*clear_line);
 			show_button_error (*import_seed);
 			import_seed->setText ("Type words 'clear keys'");
-			this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this]() {
-				this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+			this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () {
+				this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 					show_button_ok (*import_seed);
 					import_seed->setText ("Import seed");
 				}));
 			});
 		}
 	});
-	QObject::connect (seed, &QLineEdit::textChanged, [this](const QString & value) {
+	QObject::connect (seed, &QLineEdit::textChanged, [this] (const QString & value) {
 		auto pos = seed->cursorPosition ();
 		seed->setText (value.trimmed ());
 		seed->setCursorPosition (pos);
 	});
-	QObject::connect (filename, &QLineEdit::textChanged, [this](const QString & value) {
+	QObject::connect (filename, &QLineEdit::textChanged, [this] (const QString & value) {
 		auto pos = filename->cursorPosition ();
 		filename->setText (value.trimmed ());
 		filename->setCursorPosition (pos);
@@ -476,17 +476,17 @@ wallet (wallet_a)
 }
 
 nano_qt::history::history (nano::ledger & ledger_a, nano::account const & account_a, nano_qt::wallet & wallet_a) :
-window (new QWidget),
-layout (new QVBoxLayout),
-model (new QStandardItemModel),
-view (new QTableView),
-tx_window (new QWidget),
-tx_layout (new QHBoxLayout),
-tx_label (new QLabel ("Account history count:")),
-tx_count (new QSpinBox),
-ledger (ledger_a),
-account (account_a),
-wallet (wallet_a)
+	window (new QWidget),
+	layout (new QVBoxLayout),
+	model (new QStandardItemModel),
+	view (new QTableView),
+	tx_window (new QWidget),
+	tx_layout (new QHBoxLayout),
+	tx_label (new QLabel ("Account history count:")),
+	tx_count (new QSpinBox),
+	ledger (ledger_a),
+	account (account_a),
+	wallet (wallet_a)
 { /*
 	tx_count->setRange (1, 256);
 	tx_layout->addWidget (tx_label);
@@ -514,8 +514,8 @@ class short_text_visitor : public nano::block_visitor
 {
 public:
 	short_text_visitor (nano::transaction const & transaction_a, nano::ledger & ledger_a) :
-	transaction (transaction_a),
-	ledger (ledger_a)
+		transaction (transaction_a),
+		ledger (ledger_a)
 	{
 	}
 	void send_block (nano::send_block const & block_a)
@@ -641,18 +641,18 @@ void nano_qt::history::refresh ()
 }
 
 nano_qt::block_viewer::block_viewer (nano_qt::wallet & wallet_a) :
-window (new QWidget),
-layout (new QVBoxLayout),
-hash_label (new QLabel ("Hash:")),
-hash (new QLineEdit),
-block_label (new QLabel ("Block:")),
-block (new QPlainTextEdit),
-successor_label (new QLabel ("Successor:")),
-successor (new QLineEdit),
-retrieve (new QPushButton ("Retrieve")),
-rebroadcast (new QPushButton ("Rebroadcast")),
-back (new QPushButton ("Back")),
-wallet (wallet_a)
+	window (new QWidget),
+	layout (new QVBoxLayout),
+	hash_label (new QLabel ("Hash:")),
+	hash (new QLineEdit),
+	block_label (new QLabel ("Block:")),
+	block (new QPlainTextEdit),
+	successor_label (new QLabel ("Successor:")),
+	successor (new QLineEdit),
+	retrieve (new QPushButton ("Retrieve")),
+	rebroadcast (new QPushButton ("Rebroadcast")),
+	back (new QPushButton ("Back")),
+	wallet (wallet_a)
 {
 	layout->addWidget (hash_label);
 	layout->addWidget (hash);
@@ -665,10 +665,10 @@ wallet (wallet_a)
 	layout->addStretch ();
 	layout->addWidget (back);
 	window->setLayout (layout);
-	QObject::connect (back, &QPushButton::released, [this]() {
+	QObject::connect (back, &QPushButton::released, [this] () {
 		this->wallet.pop_main_stack ();
 	});
-	QObject::connect (retrieve, &QPushButton::released, [this]() {
+	QObject::connect (retrieve, &QPushButton::released, [this] () {
 		nano::block_hash hash_l;
 		if (!hash_l.decode_hex (hash->text ().toStdString ()))
 		{
@@ -692,7 +692,7 @@ wallet (wallet_a)
 			block->setPlainText ("Bad block hash");
 		}
 	});
-	QObject::connect (rebroadcast, &QPushButton::released, [this]() {
+	QObject::connect (rebroadcast, &QPushButton::released, [this] () {
 		nano::block_hash block;
 		auto error (block.decode_hex (hash->text ().toStdString ()));
 		if (!error)
@@ -701,13 +701,13 @@ wallet (wallet_a)
 			if (this->wallet.node.store.block_exists (transaction, block))
 			{
 				rebroadcast->setEnabled (false);
-				this->wallet.node.background ([this, block]() {
+				this->wallet.node.background ([this, block] () {
 					rebroadcast_action (block);
 				});
 			}
 		}
 	});
-	QObject::connect (hash, &QLineEdit::textChanged, [this](const QString & value) {
+	QObject::connect (hash, &QLineEdit::textChanged, [this] (const QString & value) {
 		auto pos = hash->cursorPosition ();
 		hash->setText (value.trimmed ());
 		hash->setCursorPosition (pos);
@@ -727,8 +727,8 @@ void nano_qt::block_viewer::rebroadcast_action (nano::block_hash const & hash_a)
 		if (!successor.is_zero ())
 		{
 			done = false;
-			wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this, successor]() {
-				this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this, successor]() {
+			wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this, successor] () {
+				this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this, successor] () {
 					rebroadcast_action (successor);
 				}));
 			});
@@ -741,18 +741,18 @@ void nano_qt::block_viewer::rebroadcast_action (nano::block_hash const & hash_a)
 }
 
 nano_qt::account_viewer::account_viewer (nano_qt::wallet & wallet_a) :
-window (new QWidget),
-layout (new QVBoxLayout),
-account_label (new QLabel ("Account:")),
-account_line (new QLineEdit),
-refresh (new QPushButton ("Refresh")),
-balance_window (new QWidget),
-balance_layout (new QHBoxLayout),
-balance_label (new QLabel),
-history (wallet_a.node.ledger, account, wallet_a),
-back (new QPushButton ("Back")),
-account (wallet_a.account),
-wallet (wallet_a)
+	window (new QWidget),
+	layout (new QVBoxLayout),
+	account_label (new QLabel ("Account:")),
+	account_line (new QLineEdit),
+	refresh (new QPushButton ("Refresh")),
+	balance_window (new QWidget),
+	balance_layout (new QHBoxLayout),
+	balance_label (new QLabel),
+	history (wallet_a.node.ledger, account, wallet_a),
+	back (new QPushButton ("Back")),
+	account (wallet_a.account),
+	wallet (wallet_a)
 {
 	layout->addWidget (account_label);
 	layout->addWidget (account_line);
@@ -765,10 +765,10 @@ wallet (wallet_a)
 	layout->addWidget (history.window);
 	layout->addWidget (back);
 	window->setLayout (layout);
-	QObject::connect (back, &QPushButton::released, [this]() {
+	QObject::connect (back, &QPushButton::released, [this] () {
 		this->wallet.pop_main_stack ();
 	});
-	QObject::connect (refresh, &QPushButton::released, [this]() {
+	QObject::connect (refresh, &QPushButton::released, [this] () {
 		account.clear ();
 		if (!account.decode_account (account_line->text ().toStdString ()))
 		{
@@ -788,7 +788,7 @@ wallet (wallet_a)
 			balance_label->clear ();
 		}
 	});
-	QObject::connect (account_line, &QLineEdit::textChanged, [this](const QString & value) {
+	QObject::connect (account_line, &QLineEdit::textChanged, [this] (const QString & value) {
 		auto pos = account_line->cursorPosition ();
 		account_line->setText (value.trimmed ());
 		account_line->setCursorPosition (pos);
@@ -796,14 +796,14 @@ wallet (wallet_a)
 }
 
 nano_qt::stats_viewer::stats_viewer (nano_qt::wallet & wallet_a) :
-window (new QWidget),
-layout (new QVBoxLayout),
-refresh (new QPushButton ("Refresh")),
-clear (new QPushButton ("Clear Statistics")),
-model (new QStandardItemModel),
-view (new QTableView),
-back (new QPushButton ("Back")),
-wallet (wallet_a)
+	window (new QWidget),
+	layout (new QVBoxLayout),
+	refresh (new QPushButton ("Refresh")),
+	clear (new QPushButton ("Clear Statistics")),
+	model (new QStandardItemModel),
+	view (new QTableView),
+	back (new QPushButton ("Back")),
+	wallet (wallet_a)
 {
 	model->setHorizontalHeaderItem (0, new QStandardItem ("Last updated"));
 	model->setHorizontalHeaderItem (1, new QStandardItem ("Type"));
@@ -821,14 +821,14 @@ wallet (wallet_a)
 	layout->addWidget (back);
 	window->setLayout (layout);
 
-	QObject::connect (back, &QPushButton::released, [this]() {
+	QObject::connect (back, &QPushButton::released, [this] () {
 		this->wallet.pop_main_stack ();
 	});
-	QObject::connect (refresh, &QPushButton::released, [this]() {
+	QObject::connect (refresh, &QPushButton::released, [this] () {
 		refresh_stats ();
 	});
 
-	QObject::connect (clear, &QPushButton::released, [this]() {
+	QObject::connect (clear, &QPushButton::released, [this] () {
 		this->wallet.node.stats.clear ();
 		refresh_stats ();
 	});
@@ -887,7 +887,7 @@ void nano_qt::stats_viewer::refresh_stats ()
 }
 
 nano_qt::status::status (nano_qt::wallet & wallet_a) :
-wallet (wallet_a)
+	wallet (wallet_a)
 {
 	wallet.status->setToolTip ("Wallet status, block count (blocks downloaded)");
 	active.insert (nano_qt::status_types::nominal);
@@ -1000,45 +1000,45 @@ std::string nano_qt::status::color ()
 }
 
 nano_qt::wallet::wallet (QApplication & application_a, nano_qt::eventloop_processor & processor_a, nano::node & node_a, std::shared_ptr<nano::wallet> const & wallet_a, nano::account & account_a) :
-rendering_ratio (nano::Mxrb_ratio),
-node (node_a),
-wallet_m (wallet_a),
-account (account_a),
-processor (processor_a),
-history (node.ledger, account, *this),
-accounts (*this),
-self (*this, account_a),
-settings (*this),
-advanced (*this),
-block_creation (*this),
-block_entry (*this),
-block_viewer (*this),
-account_viewer (*this),
-stats_viewer (*this),
-import (*this),
-application (application_a),
-status (new QLabel),
-main_stack (new QStackedWidget),
-client_window (new QWidget),
-client_layout (new QVBoxLayout),
-entry_window (new QWidget),
-entry_window_layout (new QVBoxLayout),
-separator (new QFrame),
-account_history_label (new QLabel ("Account history:")),
-send_blocks (new QPushButton ("Send")),
-settings_button (new QPushButton ("Settings")),
-accounts_button (new QPushButton ("Accounts")),
-show_advanced (new QPushButton ("Advanced")),
-send_blocks_window (new QWidget),
-send_blocks_layout (new QVBoxLayout),
-send_account_label (new QLabel ("Destination account:")),
-send_account (new QLineEdit),
-send_count_label (new QLabel ("Amount:")),
-send_count (new QLineEdit),
-send_blocks_send (new QPushButton ("Send")),
-send_blocks_back (new QPushButton ("Back")),
-active_status (*this),
-needs_deterministic_restore (false)
+	rendering_ratio (nano::Mxrb_ratio),
+	node (node_a),
+	wallet_m (wallet_a),
+	account (account_a),
+	processor (processor_a),
+	history (node.ledger, account, *this),
+	accounts (*this),
+	self (*this, account_a),
+	settings (*this),
+	advanced (*this),
+	block_creation (*this),
+	block_entry (*this),
+	block_viewer (*this),
+	account_viewer (*this),
+	stats_viewer (*this),
+	import (*this),
+	application (application_a),
+	status (new QLabel),
+	main_stack (new QStackedWidget),
+	client_window (new QWidget),
+	client_layout (new QVBoxLayout),
+	entry_window (new QWidget),
+	entry_window_layout (new QVBoxLayout),
+	separator (new QFrame),
+	account_history_label (new QLabel ("Account history:")),
+	send_blocks (new QPushButton ("Send")),
+	settings_button (new QPushButton ("Settings")),
+	accounts_button (new QPushButton ("Accounts")),
+	show_advanced (new QPushButton ("Advanced")),
+	send_blocks_window (new QWidget),
+	send_blocks_layout (new QVBoxLayout),
+	send_account_label (new QLabel ("Destination account:")),
+	send_account (new QLineEdit),
+	send_count_label (new QLabel ("Amount:")),
+	send_count (new QLineEdit),
+	send_blocks_send (new QPushButton ("Send")),
+	send_blocks_back (new QPushButton ("Back")),
+	active_status (*this),
+	needs_deterministic_restore (false)
 {
 	update_connected ();
 	empty_password ();
@@ -1082,12 +1082,12 @@ needs_deterministic_restore (false)
 	client_window->setStyleSheet ("\
 		QLineEdit { padding: 3px; } \
 	");
-	QObject::connect (send_account, &QLineEdit::textChanged, [this](const QString & value) {
+	QObject::connect (send_account, &QLineEdit::textChanged, [this] (const QString & value) {
 		auto pos = send_account->cursorPosition ();
 		send_account->setText (value.trimmed ());
 		send_account->setCursorPosition (pos);
 	});
-	QObject::connect (send_count, &QLineEdit::textChanged, [this](const QString & value) {
+	QObject::connect (send_count, &QLineEdit::textChanged, [this] (const QString & value) {
 		auto pos = send_count->cursorPosition ();
 		send_count->setText (value.trimmed ());
 		send_count->setCursorPosition (pos);
@@ -1106,7 +1106,7 @@ void nano_qt::wallet::ongoing_refresh ()
 	{
 		needs_balance_refresh = false;
 		auto balance_l (node.balance_pending (account, false));
-		application.postEvent (&processor, new eventloop_event ([wallet_w, balance_l]() {
+		application.postEvent (&processor, new eventloop_event ([wallet_w, balance_l] () {
 			if (auto this_l = wallet_w.lock ())
 			{
 				this_l->self.set_balance_text (balance_l);
@@ -1115,14 +1115,14 @@ void nano_qt::wallet::ongoing_refresh ()
 	}
 
 	// Updates the status line periodically with bootstrap status and block counts.
-	application.postEvent (&processor, new eventloop_event ([wallet_w]() {
+	application.postEvent (&processor, new eventloop_event ([wallet_w] () {
 		if (auto this_l = wallet_w.lock ())
 		{
 			this_l->active_status.set_text ();
 		}
 	}));
 
-	node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [wallet_w]() {
+	node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [wallet_w] () {
 		if (auto wallet_l = wallet_w.lock ())
 		{
 			wallet_l->ongoing_refresh ();
@@ -1134,25 +1134,25 @@ void nano_qt::wallet::start ()
 {
 	ongoing_refresh ();
 	std::weak_ptr<nano_qt::wallet> this_w (shared_from_this ());
-	QObject::connect (settings_button, &QPushButton::released, [this_w]() {
+	QObject::connect (settings_button, &QPushButton::released, [this_w] () {
 		if (auto this_l = this_w.lock ())
 		{
 			this_l->settings.activate ();
 		}
 	});
-	QObject::connect (accounts_button, &QPushButton::released, [this_w]() {
+	QObject::connect (accounts_button, &QPushButton::released, [this_w] () {
 		if (auto this_l = this_w.lock ())
 		{
 			this_l->push_main_stack (this_l->accounts.window);
 		}
 	});
-	QObject::connect (show_advanced, &QPushButton::released, [this_w]() {
+	QObject::connect (show_advanced, &QPushButton::released, [this_w] () {
 		if (auto this_l = this_w.lock ())
 		{
 			this_l->push_main_stack (this_l->advanced.window);
 		}
 	});
-	QObject::connect (send_blocks_send, &QPushButton::released, [this_w]() {
+	QObject::connect (send_blocks_send, &QPushButton::released, [this_w] () {
 		if (auto this_l = this_w.lock ())
 		{
 			show_line_ok (*this_l->send_count);
@@ -1174,14 +1174,14 @@ void nano_qt::wallet::start ()
 						if (this_l->wallet_m->store.valid_password (transaction))
 						{
 							this_l->send_blocks_send->setEnabled (false);
-							this_l->node.background ([this_w, account_l, actual]() {
+							this_l->node.background ([this_w, account_l, actual] () {
 								if (auto this_l = this_w.lock ())
 								{
-									this_l->wallet_m->send_async (this_l->account, account_l, actual, [this_w](std::shared_ptr<nano::block> const & block_a) {
+									this_l->wallet_m->send_async (this_l->account, account_l, actual, [this_w] (std::shared_ptr<nano::block> const & block_a) {
 										if (auto this_l = this_w.lock ())
 										{
 											auto succeeded (block_a != nullptr);
-											this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w, succeeded]() {
+											this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w, succeeded] () {
 												if (auto this_l = this_w.lock ())
 												{
 													this_l->send_blocks_send->setEnabled (true);
@@ -1206,10 +1206,10 @@ void nano_qt::wallet::start ()
 						{
 							show_button_error (*this_l->send_blocks_send);
 							this_l->send_blocks_send->setText ("Wallet is locked, unlock it to send");
-							this_l->node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this_w]() {
+							this_l->node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this_w] () {
 								if (auto this_l = this_w.lock ())
 								{
-									this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w]() {
+									this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w] () {
 										if (auto this_l = this_w.lock ())
 										{
 											show_button_ok (*this_l->send_blocks_send);
@@ -1225,10 +1225,10 @@ void nano_qt::wallet::start ()
 						show_line_error (*this_l->send_count);
 						show_button_error (*this_l->send_blocks_send);
 						this_l->send_blocks_send->setText ("Not enough balance");
-						this_l->node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this_w]() {
+						this_l->node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this_w] () {
 							if (auto this_l = this_w.lock ())
 							{
-								this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w]() {
+								this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w] () {
 									if (auto this_l = this_w.lock ())
 									{
 										show_button_ok (*this_l->send_blocks_send);
@@ -1244,10 +1244,10 @@ void nano_qt::wallet::start ()
 					show_line_error (*this_l->send_account);
 					show_button_error (*this_l->send_blocks_send);
 					this_l->send_blocks_send->setText ("Bad destination account");
-					this_l->node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this_w]() {
+					this_l->node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this_w] () {
 						if (auto this_l = this_w.lock ())
 						{
-							this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w]() {
+							this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w] () {
 								if (auto this_l = this_w.lock ())
 								{
 									show_button_ok (*this_l->send_blocks_send);
@@ -1263,10 +1263,10 @@ void nano_qt::wallet::start ()
 				show_line_error (*this_l->send_count);
 				show_button_error (*this_l->send_blocks_send);
 				this_l->send_blocks_send->setText ("Bad amount number");
-				this_l->node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this_w]() {
+				this_l->node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this_w] () {
 					if (auto this_l = this_w.lock ())
 					{
-						this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w]() {
+						this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w] () {
 							if (auto this_l = this_w.lock ())
 							{
 								show_button_ok (*this_l->send_blocks_send);
@@ -1278,22 +1278,22 @@ void nano_qt::wallet::start ()
 			}
 		}
 	});
-	QObject::connect (send_blocks_back, &QPushButton::released, [this_w]() {
+	QObject::connect (send_blocks_back, &QPushButton::released, [this_w] () {
 		if (auto this_l = this_w.lock ())
 		{
 			this_l->pop_main_stack ();
 		}
 	});
-	QObject::connect (send_blocks, &QPushButton::released, [this_w]() {
+	QObject::connect (send_blocks, &QPushButton::released, [this_w] () {
 		if (auto this_l = this_w.lock ())
 		{
 			this_l->push_main_stack (this_l->send_blocks_window);
 		}
 	});
-	node.observers.blocks.add ([this_w](nano::election_status const & status_a, std::vector<nano::vote_with_weight_info> const & votes_a, nano::account const & account_a, nano::uint128_t const & amount_a, bool) {
+	node.observers.blocks.add ([this_w] (nano::election_status const & status_a, std::vector<nano::vote_with_weight_info> const & votes_a, nano::account const & account_a, nano::uint128_t const & amount_a, bool) {
 		if (auto this_l = this_w.lock ())
 		{
-			this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w, status_a, account_a]() {
+			this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w, status_a, account_a] () {
 				if (auto this_l = this_w.lock ())
 				{
 					if (this_l->wallet_m->exists (account_a))
@@ -1308,16 +1308,16 @@ void nano_qt::wallet::start ()
 			}));
 		}
 	});
-	node.observers.account_balance.add ([this_w](nano::account const & account_a, bool is_pending) {
+	node.observers.account_balance.add ([this_w] (nano::account const & account_a, bool is_pending) {
 		if (auto this_l = this_w.lock ())
 		{
 			this_l->needs_balance_refresh = this_l->needs_balance_refresh || account_a == this_l->account;
 		}
 	});
-	node.observers.wallet.add ([this_w](bool active_a) {
+	node.observers.wallet.add ([this_w] (bool active_a) {
 		if (auto this_l = this_w.lock ())
 		{
-			this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w, active_a]() {
+			this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w, active_a] () {
 				if (auto this_l = this_w.lock ())
 				{
 					if (active_a)
@@ -1332,10 +1332,10 @@ void nano_qt::wallet::start ()
 			}));
 		}
 	});
-	node.observers.endpoint.add ([this_w](std::shared_ptr<nano::transport::channel> const &) {
+	node.observers.endpoint.add ([this_w] (std::shared_ptr<nano::transport::channel> const &) {
 		if (auto this_l = this_w.lock ())
 		{
-			this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w]() {
+			this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w] () {
 				if (auto this_l = this_w.lock ())
 				{
 					this_l->update_connected ();
@@ -1343,10 +1343,10 @@ void nano_qt::wallet::start ()
 			}));
 		}
 	});
-	node.observers.disconnect.add ([this_w]() {
+	node.observers.disconnect.add ([this_w] () {
 		if (auto this_l = this_w.lock ())
 		{
-			this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w]() {
+			this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w] () {
 				if (auto this_l = this_w.lock ())
 				{
 					this_l->update_connected ();
@@ -1354,10 +1354,10 @@ void nano_qt::wallet::start ()
 			}));
 		}
 	});
-	node.bootstrap_initiator.add_observer ([this_w](bool active_a) {
+	node.bootstrap_initiator.add_observer ([this_w] (bool active_a) {
 		if (auto this_l = this_w.lock ())
 		{
-			this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w, active_a]() {
+			this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w, active_a] () {
 				if (auto this_l = this_w.lock ())
 				{
 					if (active_a)
@@ -1379,10 +1379,10 @@ void nano_qt::wallet::start ()
 			}));
 		}
 	});
-	node.work.work_observers.add ([this_w](bool working) {
+	node.work.work_observers.add ([this_w] (bool working) {
 		if (auto this_l = this_w.lock ())
 		{
-			this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w, working]() {
+			this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w, working] () {
 				if (auto this_l = this_w.lock ())
 				{
 					if (working)
@@ -1397,10 +1397,10 @@ void nano_qt::wallet::start ()
 			}));
 		}
 	});
-	wallet_m->lock_observer = [this_w](bool invalid, bool vulnerable) {
+	wallet_m->lock_observer = [this_w] (bool invalid, bool vulnerable) {
 		if (auto this_l = this_w.lock ())
 		{
-			this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w, invalid, vulnerable]() {
+			this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w, invalid, vulnerable] () {
 				if (auto this_l = this_w.lock ())
 				{
 					this_l->settings.update_locked (invalid, vulnerable);
@@ -1439,7 +1439,7 @@ void nano_qt::wallet::update_connected ()
 
 void nano_qt::wallet::empty_password ()
 {
-	this->node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (3), [this]() {
+	this->node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (3), [this] () {
 		auto transaction (wallet_m->wallets.tx_begin_write ());
 		wallet_m->enter_password (transaction, std::string (""));
 	});
@@ -1447,7 +1447,7 @@ void nano_qt::wallet::empty_password ()
 
 void nano_qt::wallet::change_rendering_ratio (nano::uint128_t const & rendering_ratio_a)
 {
-	application.postEvent (&processor, new eventloop_event ([this, rendering_ratio_a]() {
+	application.postEvent (&processor, new eventloop_event ([this, rendering_ratio_a] () {
 		this->rendering_ratio = rendering_ratio_a;
 		auto balance_l (this->node.balance_pending (account, false));
 		this->self.set_balance_text (balance_l);
@@ -1486,21 +1486,21 @@ void nano_qt::wallet::pop_main_stack ()
 }
 
 nano_qt::settings::settings (nano_qt::wallet & wallet_a) :
-window (new QWidget),
-layout (new QVBoxLayout),
-password (new QLineEdit),
-lock_toggle (new QPushButton ("Unlock")),
-sep1 (new QFrame),
-new_password (new QLineEdit),
-retype_password (new QLineEdit),
-change (new QPushButton ("Set/Change password")),
-sep2 (new QFrame),
-representative (new QLabel ("Account representative:")),
-current_representative (new QLabel),
-new_representative (new QLineEdit),
-change_rep (new QPushButton ("Change representative")),
-back (new QPushButton ("Back")),
-wallet (wallet_a)
+	window (new QWidget),
+	layout (new QVBoxLayout),
+	password (new QLineEdit),
+	lock_toggle (new QPushButton ("Unlock")),
+	sep1 (new QFrame),
+	new_password (new QLineEdit),
+	retype_password (new QLineEdit),
+	change (new QPushButton ("Set/Change password")),
+	sep2 (new QFrame),
+	representative (new QLabel ("Account representative:")),
+	current_representative (new QLabel),
+	new_representative (new QLineEdit),
+	change_rep (new QPushButton ("Change representative")),
+	back (new QPushButton ("Back")),
+	wallet (wallet_a)
 {
 	password->setPlaceholderText ("Password");
 	password->setEchoMode (QLineEdit::EchoMode::Password);
@@ -1528,7 +1528,7 @@ wallet (wallet_a)
 	layout->addStretch ();
 	layout->addWidget (back);
 	window->setLayout (layout);
-	QObject::connect (change, &QPushButton::released, [this]() {
+	QObject::connect (change, &QPushButton::released, [this] () {
 		auto transaction (this->wallet.wallet_m->wallets.tx_begin_write ());
 		if (this->wallet.wallet_m->store.valid_password (transaction))
 		{
@@ -1551,8 +1551,8 @@ wallet (wallet_a)
 					change->setText ("Password was changed");
 					this->wallet.node.logger.try_log ("Wallet password changed");
 					update_locked (false, false);
-					this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this]() {
-						this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+					this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () {
+						this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 							show_button_ok (*change);
 							change->setText ("Set/Change password");
 						}));
@@ -1569,15 +1569,15 @@ wallet (wallet_a)
 		{
 			show_button_error (*change);
 			change->setText ("Wallet is locked, unlock it");
-			this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this]() {
-				this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+			this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () {
+				this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 					show_button_ok (*change);
 					change->setText ("Set/Change password");
 				}));
 			});
 		}
 	});
-	QObject::connect (change_rep, &QPushButton::released, [this]() {
+	QObject::connect (change_rep, &QPushButton::released, [this] () {
 		nano::account representative_l;
 		if (!representative_l.decode_account (new_representative->text ().toStdString ()))
 		{
@@ -1595,8 +1595,8 @@ wallet (wallet_a)
 				change_rep->setText ("Representative was changed");
 				current_representative->setText (QString (representative_l.to_account ().c_str ()));
 				new_representative->clear ();
-				this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this]() {
-					this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+				this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () {
+					this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 						show_button_ok (*change_rep);
 						change_rep->setText ("Change representative");
 					}));
@@ -1606,8 +1606,8 @@ wallet (wallet_a)
 			{
 				show_button_error (*change_rep);
 				change_rep->setText ("Wallet is locked, unlock it");
-				this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this]() {
-					this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+				this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () {
+					this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 						show_button_ok (*change_rep);
 						change_rep->setText ("Change representative");
 					}));
@@ -1619,8 +1619,8 @@ wallet (wallet_a)
 			show_line_error (*new_representative);
 			show_button_error (*change_rep);
 			change_rep->setText ("Invalid account");
-			this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this]() {
-				this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+			this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () {
+				this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 					show_line_ok (*new_representative);
 					show_button_ok (*change_rep);
 					change_rep->setText ("Change representative");
@@ -1628,11 +1628,11 @@ wallet (wallet_a)
 			});
 		}
 	});
-	QObject::connect (back, &QPushButton::released, [this]() {
+	QObject::connect (back, &QPushButton::released, [this] () {
 		debug_assert (this->wallet.main_stack->currentWidget () == window);
 		this->wallet.pop_main_stack ();
 	});
-	QObject::connect (lock_toggle, &QPushButton::released, [this]() {
+	QObject::connect (lock_toggle, &QPushButton::released, [this] () {
 		auto transaction (this->wallet.wallet_m->wallets.tx_begin_write ());
 		if (this->wallet.wallet_m->store.valid_password (transaction))
 		{
@@ -1659,8 +1659,8 @@ wallet (wallet_a)
 				show_line_error (*password);
 				show_button_error (*lock_toggle);
 				lock_toggle->setText ("Invalid password");
-				this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this]() {
-					this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this]() {
+				this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (5), [this] () {
+					this->wallet.application.postEvent (&this->wallet.processor, new eventloop_event ([this] () {
 						show_line_ok (*password);
 						show_button_ok (*lock_toggle);
 
@@ -1675,7 +1675,7 @@ wallet (wallet_a)
 			}
 		}
 	});
-	QObject::connect (new_representative, &QLineEdit::textChanged, [this](const QString & value) {
+	QObject::connect (new_representative, &QLineEdit::textChanged, [this] (const QString & value) {
 		auto pos = new_representative->cursorPosition ();
 		new_representative->setText (value.trimmed ());
 		new_representative->setCursorPosition (pos);
@@ -1735,45 +1735,45 @@ void nano_qt::settings::update_locked (bool invalid, bool vulnerable)
 }
 
 nano_qt::advanced_actions::advanced_actions (nano_qt::wallet & wallet_a) :
-window (new QWidget),
-layout (new QVBoxLayout),
-show_ledger (new QPushButton ("Ledger")),
-show_peers (new QPushButton ("Peers")),
-search_for_receivables (new QPushButton ("Search for receivables")),
-bootstrap (new QPushButton ("Initiate bootstrap")),
-wallet_refresh (new QPushButton ("Refresh Wallet")),
-create_block (new QPushButton ("Create Block")),
-enter_block (new QPushButton ("Enter Block")),
-block_viewer (new QPushButton ("Block Viewer")),
-account_viewer (new QPushButton ("Account Viewer")),
-stats_viewer (new QPushButton ("Node Statistics")),
-scale_window (new QWidget),
-scale_layout (new QHBoxLayout),
-scale_label (new QLabel ("Scale:")),
-ratio_group (new QButtonGroup),
-mnano_unit (new QRadioButton ("Mnano")),
-knano_unit (new QRadioButton ("knano")),
-nano_unit (new QRadioButton ("nano")),
-raw_unit (new QRadioButton ("raw")),
-back (new QPushButton ("Back")),
-ledger_window (new QWidget),
-ledger_layout (new QVBoxLayout),
-ledger_model (new QStandardItemModel),
-ledger_view (new QTableView),
-ledger_refresh (new QPushButton ("Refresh")),
-ledger_back (new QPushButton ("Back")),
-peers_window (new QWidget),
-peers_layout (new QVBoxLayout),
-peers_model (new QStandardItemModel),
-peers_view (new QTableView),
-peer_summary_layout (new QHBoxLayout),
-bootstrap_label (new QLabel ("IPV6:port \"::ffff:192.168.0.1:7075\"")),
-peer_count_label (new QLabel ("")),
-bootstrap_line (new QLineEdit),
-peers_bootstrap (new QPushButton ("Initiate Bootstrap")),
-peers_refresh (new QPushButton ("Refresh")),
-peers_back (new QPushButton ("Back")),
-wallet (wallet_a)
+	window (new QWidget),
+	layout (new QVBoxLayout),
+	show_ledger (new QPushButton ("Ledger")),
+	show_peers (new QPushButton ("Peers")),
+	search_for_receivables (new QPushButton ("Search for receivables")),
+	bootstrap (new QPushButton ("Initiate bootstrap")),
+	wallet_refresh (new QPushButton ("Refresh Wallet")),
+	create_block (new QPushButton ("Create Block")),
+	enter_block (new QPushButton ("Enter Block")),
+	block_viewer (new QPushButton ("Block Viewer")),
+	account_viewer (new QPushButton ("Account Viewer")),
+	stats_viewer (new QPushButton ("Node Statistics")),
+	scale_window (new QWidget),
+	scale_layout (new QHBoxLayout),
+	scale_label (new QLabel ("Scale:")),
+	ratio_group (new QButtonGroup),
+	mnano_unit (new QRadioButton ("Mnano")),
+	knano_unit (new QRadioButton ("knano")),
+	nano_unit (new QRadioButton ("nano")),
+	raw_unit (new QRadioButton ("raw")),
+	back (new QPushButton ("Back")),
+	ledger_window (new QWidget),
+	ledger_layout (new QVBoxLayout),
+	ledger_model (new QStandardItemModel),
+	ledger_view (new QTableView),
+	ledger_refresh (new QPushButton ("Refresh")),
+	ledger_back (new QPushButton ("Back")),
+	peers_window (new QWidget),
+	peers_layout (new QVBoxLayout),
+	peers_model (new QStandardItemModel),
+	peers_view (new QTableView),
+	peer_summary_layout (new QHBoxLayout),
+	bootstrap_label (new QLabel ("IPV6:port \"::ffff:192.168.0.1:7075\"")),
+	peer_count_label (new QLabel ("")),
+	bootstrap_line (new QLineEdit),
+	peers_bootstrap (new QPushButton ("Initiate Bootstrap")),
+	peers_refresh (new QPushButton ("Refresh")),
+	peers_back (new QPushButton ("Back")),
+	wallet (wallet_a)
 {
 	ratio_group->addButton (mnano_unit);
 	ratio_group->addButton (knano_unit);
@@ -1839,28 +1839,28 @@ wallet (wallet_a)
 	layout->addWidget (back);
 	window->setLayout (layout);
 
-	QObject::connect (mnano_unit, &QRadioButton::toggled, [this]() {
+	QObject::connect (mnano_unit, &QRadioButton::toggled, [this] () {
 		if (mnano_unit->isChecked ())
 		{
 			QSettings ().setValue (saved_ratio_key, ratio_group->id (mnano_unit));
 			this->wallet.change_rendering_ratio (nano::Mxrb_ratio);
 		}
 	});
-	QObject::connect (knano_unit, &QRadioButton::toggled, [this]() {
+	QObject::connect (knano_unit, &QRadioButton::toggled, [this] () {
 		if (knano_unit->isChecked ())
 		{
 			QSettings ().setValue (saved_ratio_key, ratio_group->id (knano_unit));
 			this->wallet.change_rendering_ratio (nano::kxrb_ratio);
 		}
 	});
-	QObject::connect (nano_unit, &QRadioButton::toggled, [this]() {
+	QObject::connect (nano_unit, &QRadioButton::toggled, [this] () {
 		if (nano_unit->isChecked ())
 		{
 			QSettings ().setValue (saved_ratio_key, ratio_group->id (nano_unit));
 			this->wallet.change_rendering_ratio (nano::xrb_ratio);
 		}
 	});
-	QObject::connect (raw_unit, &QRadioButton::toggled, [this]() {
+	QObject::connect (raw_unit, &QRadioButton::toggled, [this] () {
 		if (raw_unit->isChecked ())
 		{
 			QSettings ().setValue (saved_ratio_key, ratio_group->id (raw_unit));
@@ -1879,24 +1879,24 @@ wallet (wallet_a)
 	{
 		mnano_unit->click ();
 	}
-	QObject::connect (wallet_refresh, &QPushButton::released, [this]() {
+	QObject::connect (wallet_refresh, &QPushButton::released, [this] () {
 		this->wallet.accounts.refresh ();
 		this->wallet.accounts.refresh_wallet_balance ();
 	});
-	QObject::connect (show_peers, &QPushButton::released, [this]() {
+	QObject::connect (show_peers, &QPushButton::released, [this] () {
 		refresh_peers ();
 		this->wallet.push_main_stack (peers_window);
 	});
-	QObject::connect (show_ledger, &QPushButton::released, [this]() {
+	QObject::connect (show_ledger, &QPushButton::released, [this] () {
 		this->wallet.push_main_stack (ledger_window);
 	});
-	QObject::connect (back, &QPushButton::released, [this]() {
+	QObject::connect (back, &QPushButton::released, [this] () {
 		this->wallet.pop_main_stack ();
 	});
-	QObject::connect (peers_back, &QPushButton::released, [this]() {
+	QObject::connect (peers_back, &QPushButton::released, [this] () {
 		this->wallet.pop_main_stack ();
 	});
-	QObject::connect (peers_bootstrap, &QPushButton::released, [this]() {
+	QObject::connect (peers_bootstrap, &QPushButton::released, [this] () {
 		nano::endpoint endpoint;
 		auto error (nano::parse_endpoint (bootstrap_line->text ().toStdString (), endpoint));
 		if (!error)
@@ -1910,34 +1910,34 @@ wallet (wallet_a)
 			show_line_error (*bootstrap_line);
 		}
 	});
-	QObject::connect (peers_refresh, &QPushButton::released, [this]() {
+	QObject::connect (peers_refresh, &QPushButton::released, [this] () {
 		refresh_peers ();
 	});
-	QObject::connect (ledger_refresh, &QPushButton::released, [this]() {
+	QObject::connect (ledger_refresh, &QPushButton::released, [this] () {
 		refresh_ledger ();
 	});
-	QObject::connect (ledger_back, &QPushButton::released, [this]() {
+	QObject::connect (ledger_back, &QPushButton::released, [this] () {
 		this->wallet.pop_main_stack ();
 	});
-	QObject::connect (search_for_receivables, &QPushButton::released, [this]() {
+	QObject::connect (search_for_receivables, &QPushButton::released, [this] () {
 		std::thread ([this] { this->wallet.wallet_m->search_pending (this->wallet.wallet_m->wallets.tx_begin_read ()); }).detach ();
 	});
-	QObject::connect (bootstrap, &QPushButton::released, [this]() {
+	QObject::connect (bootstrap, &QPushButton::released, [this] () {
 		std::thread ([this] { this->wallet.node.bootstrap_initiator.bootstrap (); }).detach ();
 	});
-	QObject::connect (create_block, &QPushButton::released, [this]() {
+	QObject::connect (create_block, &QPushButton::released, [this] () {
 		this->wallet.push_main_stack (this->wallet.block_creation.window);
 	});
-	QObject::connect (enter_block, &QPushButton::released, [this]() {
+	QObject::connect (enter_block, &QPushButton::released, [this] () {
 		this->wallet.push_main_stack (this->wallet.block_entry.window);
 	});
-	QObject::connect (block_viewer, &QPushButton::released, [this]() {
+	QObject::connect (block_viewer, &QPushButton::released, [this] () {
 		this->wallet.push_main_stack (this->wallet.block_viewer.window);
 	});
-	QObject::connect (account_viewer, &QPushButton::released, [this]() {
+	QObject::connect (account_viewer, &QPushButton::released, [this] () {
 		this->wallet.push_main_stack (this->wallet.account_viewer.window);
 	});
-	QObject::connect (stats_viewer, &QPushButton::released, [this]() {
+	QObject::connect (stats_viewer, &QPushButton::released, [this] () {
 		this->wallet.push_main_stack (this->wallet.stats_viewer.window);
 		this->wallet.stats_viewer.refresh_stats ();
 	});
@@ -1952,7 +1952,7 @@ void nano_qt::advanced_actions::refresh_peers ()
 {
 	peers_model->removeRows (0, peers_model->rowCount ());
 	auto list (wallet.node.network.list (std::numeric_limits<size_t>::max ()));
-	std::sort (list.begin (), list.end (), [](const auto & lhs, const auto & rhs) {
+	std::sort (list.begin (), list.end (), [] (const auto & lhs, const auto & rhs) {
 		return lhs->get_endpoint () < rhs->get_endpoint ();
 	});
 	for (auto i (list.begin ()), n (list.end ()); i != n; ++i)
@@ -2003,20 +2003,20 @@ void nano_qt::advanced_actions::refresh_stats ()
 }
 
 nano_qt::block_entry::block_entry (nano_qt::wallet & wallet_a) :
-window (new QWidget),
-layout (new QVBoxLayout),
-block (new QPlainTextEdit),
-status (new QLabel),
-process (new QPushButton ("Process")),
-back (new QPushButton ("Back")),
-wallet (wallet_a)
+	window (new QWidget),
+	layout (new QVBoxLayout),
+	block (new QPlainTextEdit),
+	status (new QLabel),
+	process (new QPushButton ("Process")),
+	back (new QPushButton ("Back")),
+	wallet (wallet_a)
 {
 	layout->addWidget (block);
 	layout->addWidget (status);
 	layout->addWidget (process);
 	layout->addWidget (back);
 	window->setLayout (layout);
-	QObject::connect (process, &QPushButton::released, [this]() {
+	QObject::connect (process, &QPushButton::released, [this] () {
 		auto string (block->toPlainText ().toStdString ());
 		try
 		{
@@ -2050,35 +2050,35 @@ wallet (wallet_a)
 			this->status->setText ("Unable to parse block");
 		}
 	});
-	QObject::connect (back, &QPushButton::released, [this]() {
+	QObject::connect (back, &QPushButton::released, [this] () {
 		this->wallet.pop_main_stack ();
 	});
 }
 
 nano_qt::block_creation::block_creation (nano_qt::wallet & wallet_a) :
-window (new QWidget),
-layout (new QVBoxLayout),
-group (new QButtonGroup),
-button_layout (new QHBoxLayout),
-send (new QRadioButton ("Send")),
-receive (new QRadioButton ("Receive")),
-change (new QRadioButton ("Change")),
-open (new QRadioButton ("Open")),
-account_label (new QLabel ("Account:")),
-account (new QLineEdit),
-source_label (new QLabel ("Source:")),
-source (new QLineEdit),
-amount_label (new QLabel ("Amount:")),
-amount (new QLineEdit),
-destination_label (new QLabel ("Destination:")),
-destination (new QLineEdit),
-representative_label (new QLabel ("Representative:")),
-representative (new QLineEdit),
-block (new QPlainTextEdit),
-status (new QLabel),
-create (new QPushButton ("Create")),
-back (new QPushButton ("Back")),
-wallet (wallet_a)
+	window (new QWidget),
+	layout (new QVBoxLayout),
+	group (new QButtonGroup),
+	button_layout (new QHBoxLayout),
+	send (new QRadioButton ("Send")),
+	receive (new QRadioButton ("Receive")),
+	change (new QRadioButton ("Change")),
+	open (new QRadioButton ("Open")),
+	account_label (new QLabel ("Account:")),
+	account (new QLineEdit),
+	source_label (new QLabel ("Source:")),
+	source (new QLineEdit),
+	amount_label (new QLabel ("Amount:")),
+	amount (new QLineEdit),
+	destination_label (new QLabel ("Destination:")),
+	destination (new QLineEdit),
+	representative_label (new QLabel ("Representative:")),
+	representative (new QLineEdit),
+	block (new QPlainTextEdit),
+	status (new QLabel),
+	create (new QPushButton ("Create")),
+	back (new QPushButton ("Back")),
+	wallet (wallet_a)
 {
 	group->addButton (send);
 	group->addButton (receive);
@@ -2110,35 +2110,35 @@ wallet (wallet_a)
 	layout->addWidget (create);
 	layout->addWidget (back);
 	window->setLayout (layout);
-	QObject::connect (send, &QRadioButton::toggled, [this](bool on) {
+	QObject::connect (send, &QRadioButton::toggled, [this] (bool on) {
 		if (on)
 		{
 			deactivate_all ();
 			activate_send ();
 		}
 	});
-	QObject::connect (receive, &QRadioButton::toggled, [this](bool on) {
+	QObject::connect (receive, &QRadioButton::toggled, [this] (bool on) {
 		if (on)
 		{
 			deactivate_all ();
 			activate_receive ();
 		}
 	});
-	QObject::connect (open, &QRadioButton::toggled, [this](bool on) {
+	QObject::connect (open, &QRadioButton::toggled, [this] (bool on) {
 		if (on)
 		{
 			deactivate_all ();
 			activate_open ();
 		}
 	});
-	QObject::connect (change, &QRadioButton::toggled, [this](bool on) {
+	QObject::connect (change, &QRadioButton::toggled, [this] (bool on) {
 		if (on)
 		{
 			deactivate_all ();
 			activate_change ();
 		}
 	});
-	QObject::connect (create, &QPushButton::released, [this]() {
+	QObject::connect (create, &QPushButton::released, [this] () {
 		switch (group->checkedId ())
 		{
 			case 0:
@@ -2158,30 +2158,30 @@ wallet (wallet_a)
 				break;
 		}
 	});
-	QObject::connect (back, &QPushButton::released, [this]() {
+	QObject::connect (back, &QPushButton::released, [this] () {
 		this->wallet.pop_main_stack ();
 	});
-	QObject::connect (account, &QLineEdit::textChanged, [this](const QString & value) {
+	QObject::connect (account, &QLineEdit::textChanged, [this] (const QString & value) {
 		auto pos = account->cursorPosition ();
 		account->setText (value.trimmed ());
 		account->setCursorPosition (pos);
 	});
-	QObject::connect (destination, &QLineEdit::textChanged, [this](const QString & value) {
+	QObject::connect (destination, &QLineEdit::textChanged, [this] (const QString & value) {
 		auto pos = destination->cursorPosition ();
 		destination->setText (value.trimmed ());
 		destination->setCursorPosition (pos);
 	});
-	QObject::connect (amount, &QLineEdit::textChanged, [this](const QString & value) {
+	QObject::connect (amount, &QLineEdit::textChanged, [this] (const QString & value) {
 		auto pos = amount->cursorPosition ();
 		amount->setText (value.trimmed ());
 		amount->setCursorPosition (pos);
 	});
-	QObject::connect (source, &QLineEdit::textChanged, [this](const QString & value) {
+	QObject::connect (source, &QLineEdit::textChanged, [this] (const QString & value) {
 		auto pos = source->cursorPosition ();
 		source->setText (value.trimmed ());
 		source->setCursorPosition (pos);
 	});
-	QObject::connect (representative, &QLineEdit::textChanged, [this](const QString & value) {
+	QObject::connect (representative, &QLineEdit::textChanged, [this] (const QString & value) {
 		auto pos = representative->cursorPosition ();
 		representative->setText (value.trimmed ());
 		representative->setCursorPosition (pos);
diff --git a/nano/qt/qt.hpp b/nano/qt/qt.hpp
index 8f9edde15c..4147dbc95d 100644
--- a/nano/qt/qt.hpp
+++ b/nano/qt/qt.hpp
@@ -20,8 +20,8 @@ class eventloop_processor : public QObject
 class eventloop_event : public QEvent
 {
 public:
-	eventloop_event (std::function<void()> const &);
-	std::function<void()> action;
+	eventloop_event (std::function<void ()> const &);
+	std::function<void ()> action;
 };
 class settings
 {
diff --git a/nano/qt_system/entry.cpp b/nano/qt_system/entry.cpp
index 1166b34955..bcda125b60 100644
--- a/nano/qt_system/entry.cpp
+++ b/nano/qt_system/entry.cpp
@@ -31,7 +31,7 @@ int main (int argc, char ** argv)
 		client_tabs->addTab (guis.back ()->client_window, boost::str (boost::format ("Wallet %1%") % i).c_str ());
 	}
 	client_tabs->show ();
-	QObject::connect (&application, &QApplication::aboutToQuit, [&]() {
+	QObject::connect (&application, &QApplication::aboutToQuit, [&] () {
 		system.stop ();
 	});
 	int result;
diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp
index d625b92745..8de536a84f 100644
--- a/nano/qt_test/qt.cpp
+++ b/nano/qt_test/qt.cpp
@@ -38,7 +38,7 @@ TEST (wallet, status)
 	wallet_l->insert_adhoc (key.prv);
 	auto wallet (std::make_shared<nano_qt::wallet> (*test_application, processor, *system.nodes[0], wallet_l, key.pub));
 	wallet->start ();
-	auto wallet_has = [wallet](nano_qt::status_types status_ty) {
+	auto wallet_has = [wallet] (nano_qt::status_types status_ty) {
 		return wallet->active_status.active.find (status_ty) != wallet->active_status.active.end ();
 	};
 	ASSERT_EQ ("Status: Disconnected, Blocks: 1", wallet->status->text ().toStdString ());
@@ -915,7 +915,7 @@ TEST (wallet, epoch_2_validation)
 	QTest::mouseClick (wallet->show_advanced, Qt::LeftButton);
 	QTest::mouseClick (wallet->advanced.create_block, Qt::LeftButton);
 
-	auto create_and_process = [&]() -> nano::block_hash {
+	auto create_and_process = [&] () -> nano::block_hash {
 		wallet->block_creation.create->click ();
 		std::string json (wallet->block_creation.block->toPlainText ().toStdString ());
 		EXPECT_FALSE (json.empty ());
@@ -929,7 +929,7 @@ TEST (wallet, epoch_2_validation)
 		return block.hash ();
 	};
 
-	auto do_send = [&](nano::public_key const & destination) -> nano::block_hash {
+	auto do_send = [&] (nano::public_key const & destination) -> nano::block_hash {
 		wallet->block_creation.send->click ();
 		wallet->block_creation.account->setText (nano::dev_genesis_key.pub.to_account ().c_str ());
 		wallet->block_creation.amount->setText ("1");
@@ -937,20 +937,20 @@ TEST (wallet, epoch_2_validation)
 		return create_and_process ();
 	};
 
-	auto do_open = [&](nano::block_hash const & source, nano::public_key const & account) -> nano::block_hash {
+	auto do_open = [&] (nano::block_hash const & source, nano::public_key const & account) -> nano::block_hash {
 		wallet->block_creation.open->click ();
 		wallet->block_creation.source->setText (source.to_string ().c_str ());
 		wallet->block_creation.representative->setText (account.to_account ().c_str ());
 		return create_and_process ();
 	};
 
-	auto do_receive = [&](nano::block_hash const & source) -> nano::block_hash {
+	auto do_receive = [&] (nano::block_hash const & source) -> nano::block_hash {
 		wallet->block_creation.receive->click ();
 		wallet->block_creation.source->setText (source.to_string ().c_str ());
 		return create_and_process ();
 	};
 
-	auto do_change = [&](nano::public_key const & account, nano::public_key const & representative) -> nano::block_hash {
+	auto do_change = [&] (nano::public_key const & account, nano::public_key const & representative) -> nano::block_hash {
 		wallet->block_creation.change->click ();
 		wallet->block_creation.account->setText (account.to_account ().c_str ());
 		wallet->block_creation.representative->setText (representative.to_account ().c_str ());
diff --git a/nano/rpc/rpc.cpp b/nano/rpc/rpc.cpp
index a121394544..d3bdb7b8db 100644
--- a/nano/rpc/rpc.cpp
+++ b/nano/rpc/rpc.cpp
@@ -12,11 +12,11 @@
 #endif
 
 nano::rpc::rpc (boost::asio::io_context & io_ctx_a, nano::rpc_config const & config_a, nano::rpc_handler_interface & rpc_handler_interface_a) :
-config (config_a),
-acceptor (io_ctx_a),
-logger (std::chrono::milliseconds (0)),
-io_ctx (io_ctx_a),
-rpc_handler_interface (rpc_handler_interface_a)
+	config (config_a),
+	acceptor (io_ctx_a),
+	logger (std::chrono::milliseconds (0)),
+	io_ctx (io_ctx_a),
+	rpc_handler_interface (rpc_handler_interface_a)
 {
 	rpc_handler_interface.rpc_instance (*this);
 }
@@ -56,7 +56,7 @@ void nano::rpc::start ()
 void nano::rpc::accept ()
 {
 	auto connection (std::make_shared<nano::rpc_connection> (config, io_ctx, logger, rpc_handler_interface));
-	acceptor.async_accept (connection->socket, boost::asio::bind_executor (connection->strand, [this, connection](boost::system::error_code const & ec) {
+	acceptor.async_accept (connection->socket, boost::asio::bind_executor (connection->strand, [this, connection] (boost::system::error_code const & ec) {
 		if (ec != boost::asio::error::operation_aborted && acceptor.is_open ())
 		{
 			accept ();
diff --git a/nano/rpc/rpc_connection.cpp b/nano/rpc/rpc_connection.cpp
index 9c20b62179..9a9b565bb6 100644
--- a/nano/rpc/rpc_connection.cpp
+++ b/nano/rpc/rpc_connection.cpp
@@ -15,12 +15,12 @@
 #include <boost/format.hpp>
 
 nano::rpc_connection::rpc_connection (nano::rpc_config const & rpc_config, boost::asio::io_context & io_ctx, nano::logger_mt & logger, nano::rpc_handler_interface & rpc_handler_interface) :
-socket (io_ctx),
-strand (io_ctx.get_executor ()),
-io_ctx (io_ctx),
-logger (logger),
-rpc_config (rpc_config),
-rpc_handler_interface (rpc_handler_interface)
+	socket (io_ctx),
+	strand (io_ctx.get_executor ()),
+	io_ctx (io_ctx),
+	logger (logger),
+	rpc_config (rpc_config),
+	rpc_handler_interface (rpc_handler_interface)
 {
 	responded.clear ();
 }
@@ -68,7 +68,7 @@ void nano::rpc_connection::read (STREAM_TYPE & stream)
 	auto header_parser (std::make_shared<boost::beast::http::request_parser<boost::beast::http::empty_body>> ());
 	header_parser->body_limit (rpc_config.max_request_size);
 
-	boost::beast::http::async_read_header (stream, buffer, *header_parser, boost::asio::bind_executor (strand, [this_l, &stream, header_parser](boost::system::error_code const & ec, size_t bytes_transferred) {
+	boost::beast::http::async_read_header (stream, buffer, *header_parser, boost::asio::bind_executor (strand, [this_l, &stream, header_parser] (boost::system::error_code const & ec, size_t bytes_transferred) {
 		if (!ec)
 		{
 			if (boost::iequals (header_parser->get ()[boost::beast::http::field::expect], "100-continue"))
@@ -77,7 +77,7 @@ void nano::rpc_connection::read (STREAM_TYPE & stream)
 				continue_response->version (11);
 				continue_response->result (boost::beast::http::status::continue_);
 				continue_response->set (boost::beast::http::field::server, "nano");
-				boost::beast::http::async_write (stream, *continue_response, boost::asio::bind_executor (this_l->strand, [this_l, continue_response](boost::system::error_code const & ec, size_t bytes_transferred) {}));
+				boost::beast::http::async_write (stream, *continue_response, boost::asio::bind_executor (this_l->strand, [this_l, continue_response] (boost::system::error_code const & ec, size_t bytes_transferred) {}));
 			}
 
 			this_l->parse_request (stream, header_parser);
@@ -87,9 +87,9 @@ void nano::rpc_connection::read (STREAM_TYPE & stream)
 			this_l->logger.always_log ("RPC header error: ", ec.message ());
 
 			// Respond with the reason for the invalid header
-			auto response_handler ([this_l, &stream](std::string const & tree_a) {
+			auto response_handler ([this_l, &stream] (std::string const & tree_a) {
 				this_l->write_result (tree_a, 11);
-				boost::beast::http::async_write (stream, this_l->res, boost::asio::bind_executor (this_l->strand, [this_l](boost::system::error_code const & ec, size_t bytes_transferred) {
+				boost::beast::http::async_write (stream, this_l->res, boost::asio::bind_executor (this_l->strand, [this_l] (boost::system::error_code const & ec, size_t bytes_transferred) {
 					this_l->write_completion_handler (this_l);
 				}));
 			});
@@ -106,20 +106,20 @@ void nano::rpc_connection::parse_request (STREAM_TYPE & stream, std::shared_ptr<
 	auto header_corr_id_l (header_parser->get ()["nano-correlation-id"]);
 	auto body_parser (std::make_shared<boost::beast::http::request_parser<boost::beast::http::string_body>> (std::move (*header_parser)));
 	auto path_l (body_parser->get ().target ().to_string ());
-	boost::beast::http::async_read (stream, buffer, *body_parser, boost::asio::bind_executor (strand, [this_l, body_parser, header_field_credentials_l, header_corr_id_l, path_l, &stream](boost::system::error_code const & ec, size_t bytes_transferred) {
+	boost::beast::http::async_read (stream, buffer, *body_parser, boost::asio::bind_executor (strand, [this_l, body_parser, header_field_credentials_l, header_corr_id_l, path_l, &stream] (boost::system::error_code const & ec, size_t bytes_transferred) {
 		if (!ec)
 		{
-			this_l->io_ctx.post ([this_l, body_parser, header_field_credentials_l, header_corr_id_l, path_l, &stream]() {
+			this_l->io_ctx.post ([this_l, body_parser, header_field_credentials_l, header_corr_id_l, path_l, &stream] () {
 				auto & req (body_parser->get ());
 				auto start (std::chrono::steady_clock::now ());
 				auto version (req.version ());
 				std::stringstream ss;
 				ss << std::hex << std::showbase << reinterpret_cast<uintptr_t> (this_l.get ());
 				auto request_id = ss.str ();
-				auto response_handler ([this_l, version, start, request_id, &stream](std::string const & tree_a) {
+				auto response_handler ([this_l, version, start, request_id, &stream] (std::string const & tree_a) {
 					auto body = tree_a;
 					this_l->write_result (body, version);
-					boost::beast::http::async_write (stream, this_l->res, boost::asio::bind_executor (this_l->strand, [this_l](boost::system::error_code const & ec, size_t bytes_transferred) {
+					boost::beast::http::async_write (stream, this_l->res, boost::asio::bind_executor (this_l->strand, [this_l] (boost::system::error_code const & ec, size_t bytes_transferred) {
 						this_l->write_completion_handler (this_l);
 					}));
 
@@ -153,7 +153,7 @@ void nano::rpc_connection::parse_request (STREAM_TYPE & stream, std::shared_ptr<
 					{
 						this_l->prepare_head (version);
 						this_l->res.prepare_payload ();
-						boost::beast::http::async_write (stream, this_l->res, boost::asio::bind_executor (this_l->strand, [this_l](boost::system::error_code const & ec, size_t bytes_transferred) {
+						boost::beast::http::async_write (stream, this_l->res, boost::asio::bind_executor (this_l->strand, [this_l] (boost::system::error_code const & ec, size_t bytes_transferred) {
 							this_l->write_completion_handler (this_l);
 						}));
 						break;
diff --git a/nano/rpc/rpc_connection_secure.cpp b/nano/rpc/rpc_connection_secure.cpp
index a1087f601a..64626b69b4 100644
--- a/nano/rpc/rpc_connection_secure.cpp
+++ b/nano/rpc/rpc_connection_secure.cpp
@@ -5,8 +5,8 @@
 #include <boost/polymorphic_pointer_cast.hpp>
 
 nano::rpc_connection_secure::rpc_connection_secure (nano::rpc_config const & rpc_config, boost::asio::io_context & io_ctx, nano::logger_mt & logger, nano::rpc_handler_interface & rpc_handler_interface, boost::asio::ssl::context & ssl_context) :
-nano::rpc_connection (rpc_config, io_ctx, logger, rpc_handler_interface),
-stream (socket, ssl_context)
+	nano::rpc_connection (rpc_config, io_ctx, logger, rpc_handler_interface),
+	stream (socket, ssl_context)
 {
 }
 
@@ -15,7 +15,7 @@ void nano::rpc_connection_secure::parse_connection ()
 	// Perform the SSL handshake
 	auto this_l = std::static_pointer_cast<nano::rpc_connection_secure> (shared_from_this ());
 	stream.async_handshake (boost::asio::ssl::stream_base::server,
-	boost::asio::bind_executor (this_l->strand, [this_l](auto & ec) {
+	boost::asio::bind_executor (this_l->strand, [this_l] (auto & ec) {
 		this_l->handle_handshake (ec);
 	}));
 }
@@ -41,7 +41,7 @@ void nano::rpc_connection_secure::handle_handshake (const boost::system::error_c
 void nano::rpc_connection_secure::write_completion_handler (std::shared_ptr<nano::rpc_connection> const & rpc)
 {
 	auto rpc_connection_secure = boost::polymorphic_pointer_downcast<nano::rpc_connection_secure> (rpc);
-	rpc_connection_secure->stream.async_shutdown (boost::asio::bind_executor (rpc->strand, [rpc_connection_secure](auto const & ec_shutdown) {
+	rpc_connection_secure->stream.async_shutdown (boost::asio::bind_executor (rpc->strand, [rpc_connection_secure] (auto const & ec_shutdown) {
 		rpc_connection_secure->on_shutdown (ec_shutdown);
 	}));
 }
diff --git a/nano/rpc/rpc_handler.cpp b/nano/rpc/rpc_handler.cpp
index e5b76f0163..e9379e14c8 100644
--- a/nano/rpc/rpc_handler.cpp
+++ b/nano/rpc/rpc_handler.cpp
@@ -18,13 +18,13 @@ std::unordered_set<std::string> rpc_control_impl_set = create_rpc_control_impls
 std::string filter_request (boost::property_tree::ptree tree_a);
 }
 
-nano::rpc_handler::rpc_handler (nano::rpc_config const & rpc_config, std::string const & body_a, std::string const & request_id_a, std::function<void(std::string const &)> const & response_a, nano::rpc_handler_interface & rpc_handler_interface_a, nano::logger_mt & logger) :
-body (body_a),
-request_id (request_id_a),
-response (response_a),
-rpc_config (rpc_config),
-rpc_handler_interface (rpc_handler_interface_a),
-logger (logger)
+nano::rpc_handler::rpc_handler (nano::rpc_config const & rpc_config, std::string const & body_a, std::string const & request_id_a, std::function<void (std::string const &)> const & response_a, nano::rpc_handler_interface & rpc_handler_interface_a, nano::logger_mt & logger) :
+	body (body_a),
+	request_id (request_id_a),
+	response (response_a),
+	rpc_config (rpc_config),
+	rpc_handler_interface (rpc_handler_interface_a),
+	logger (logger)
 {
 }
 
@@ -122,7 +122,7 @@ void nano::rpc_handler::process_request (nano::rpc_handler_request_params const
 			}
 			else if (request_params.rpc_version == 2)
 			{
-				rpc_handler_interface.process_request_v2 (request_params, body, [response = response](std::shared_ptr<std::string> const & body) {
+				rpc_handler_interface.process_request_v2 (request_params, body, [response = response] (std::shared_ptr<std::string> const & body) {
 					std::string body_l = *body;
 					response (body_l);
 				});
diff --git a/nano/rpc/rpc_handler.hpp b/nano/rpc/rpc_handler.hpp
index bc75b6e15f..2e919f303a 100644
--- a/nano/rpc/rpc_handler.hpp
+++ b/nano/rpc/rpc_handler.hpp
@@ -15,14 +15,14 @@ class rpc_handler_request_params;
 class rpc_handler : public std::enable_shared_from_this<nano::rpc_handler>
 {
 public:
-	rpc_handler (nano::rpc_config const & rpc_config, std::string const & body_a, std::string const & request_id_a, std::function<void(std::string const &)> const & response_a, nano::rpc_handler_interface & rpc_handler_interface_a, nano::logger_mt & logger);
+	rpc_handler (nano::rpc_config const & rpc_config, std::string const & body_a, std::string const & request_id_a, std::function<void (std::string const &)> const & response_a, nano::rpc_handler_interface & rpc_handler_interface_a, nano::logger_mt & logger);
 	void process_request (nano::rpc_handler_request_params const & request_params);
 
 private:
 	std::string body;
 	std::string request_id;
 	boost::property_tree::ptree request;
-	std::function<void(std::string const &)> response;
+	std::function<void (std::string const &)> response;
 	nano::rpc_config const & rpc_config;
 	nano::rpc_handler_interface & rpc_handler_interface;
 	nano::logger_mt & logger;
diff --git a/nano/rpc/rpc_request_processor.cpp b/nano/rpc/rpc_request_processor.cpp
index 621aa212e6..96f7c78890 100644
--- a/nano/rpc/rpc_request_processor.cpp
+++ b/nano/rpc/rpc_request_processor.cpp
@@ -6,12 +6,12 @@
 #include <boost/endian/conversion.hpp>
 
 nano::rpc_request_processor::rpc_request_processor (boost::asio::io_context & io_ctx, nano::rpc_config & rpc_config) :
-ipc_address (rpc_config.rpc_process.ipc_address),
-ipc_port (rpc_config.rpc_process.ipc_port),
-thread ([this]() {
-	nano::thread_role::set (nano::thread_role::name::rpc_request_processor);
-	this->run ();
-})
+	ipc_address (rpc_config.rpc_process.ipc_address),
+	ipc_port (rpc_config.rpc_process.ipc_port),
+	thread ([this] () {
+		nano::thread_role::set (nano::thread_role::name::rpc_request_processor);
+		this->run ();
+	})
 {
 	nano::lock_guard<nano::mutex> lk (this->request_mutex);
 	this->connections.reserve (rpc_config.rpc_process.num_ipc_connections);
@@ -19,7 +19,7 @@ thread ([this]() {
 	{
 		connections.push_back (std::make_shared<nano::ipc_connection> (nano::ipc::ipc_client (io_ctx), false));
 		auto connection = this->connections.back ();
-		connection->client.async_connect (ipc_address, ipc_port, [connection, &connections_mutex = this->connections_mutex](nano::error err) {
+		connection->client.async_connect (ipc_address, ipc_port, [connection, &connections_mutex = this->connections_mutex] (nano::error err) {
 			// Even if there is an error this needs to be set so that another attempt can be made to connect with the ipc connection
 			nano::lock_guard<nano::mutex> lk (connections_mutex);
 			connection->is_available = true;
@@ -59,7 +59,7 @@ void nano::rpc_request_processor::read_payload (std::shared_ptr<nano::ipc_connec
 	uint32_t payload_size_l = boost::endian::big_to_native (*reinterpret_cast<uint32_t *> (res->data ()));
 	res->resize (payload_size_l);
 	// Read JSON payload
-	connection->client.async_read (res, payload_size_l, [this, connection, res, rpc_request](nano::error err_read_a, size_t size_read_a) {
+	connection->client.async_read (res, payload_size_l, [this, connection, res, rpc_request] (nano::error err_read_a, size_t size_read_a) {
 		// We need 2 sequential reads to get both the header and payload, so only allow other writes
 		// when they have both been read.
 		make_available (*connection);
@@ -87,14 +87,14 @@ void nano::rpc_request_processor::make_available (nano::ipc_connection & connect
 // Connection does not exist or has been closed, try to connect to it again and then resend IPC request
 void nano::rpc_request_processor::try_reconnect_and_execute_request (std::shared_ptr<nano::ipc_connection> const & connection, nano::shared_const_buffer const & req, std::shared_ptr<std::vector<uint8_t>> const & res, std::shared_ptr<nano::rpc_request> const & rpc_request)
 {
-	connection->client.async_connect (ipc_address, ipc_port, [this, connection, req, res, rpc_request](nano::error err) {
+	connection->client.async_connect (ipc_address, ipc_port, [this, connection, req, res, rpc_request] (nano::error err) {
 		if (!err)
 		{
-			connection->client.async_write (req, [this, connection, res, rpc_request](nano::error err_a, size_t size_a) {
+			connection->client.async_write (req, [this, connection, res, rpc_request] (nano::error err_a, size_t size_a) {
 				if (size_a != 0 && !err_a)
 				{
 					// Read length
-					connection->client.async_read (res, sizeof (uint32_t), [this, connection, res, rpc_request](nano::error err_read_a, size_t size_read_a) {
+					connection->client.async_read (res, sizeof (uint32_t), [this, connection, res, rpc_request] (nano::error err_read_a, size_t size_read_a) {
 						if (size_read_a != 0 && !err_read_a)
 						{
 							this->read_payload (connection, res, rpc_request);
@@ -132,7 +132,7 @@ void nano::rpc_request_processor::run ()
 			lk.unlock ();
 			nano::unique_lock<nano::mutex> conditions_lk (connections_mutex);
 			// Find the first free ipc_client
-			auto it = std::find_if (connections.begin (), connections.end (), [](auto connection) -> bool {
+			auto it = std::find_if (connections.begin (), connections.end (), [] (auto connection) -> bool {
 				return connection->is_available;
 			});
 
@@ -151,10 +151,10 @@ void nano::rpc_request_processor::run ()
 				auto res (std::make_shared<std::vector<uint8_t>> ());
 
 				// Have we tried to connect yet?
-				connection->client.async_write (req, [this, connection, req, res, rpc_request](nano::error err_a, size_t size_a) {
+				connection->client.async_write (req, [this, connection, req, res, rpc_request] (nano::error err_a, size_t size_a) {
 					if (!err_a)
 					{
-						connection->client.async_read (res, sizeof (uint32_t), [this, connection, req, res, rpc_request](nano::error err_read_a, size_t size_read_a) {
+						connection->client.async_read (res, sizeof (uint32_t), [this, connection, req, res, rpc_request] (nano::error err_read_a, size_t size_read_a) {
 							if (size_read_a != 0 && !err_read_a)
 							{
 								this->read_payload (connection, res, rpc_request);
diff --git a/nano/rpc/rpc_request_processor.hpp b/nano/rpc/rpc_request_processor.hpp
index dae034cc80..0b0da628e7 100644
--- a/nano/rpc/rpc_request_processor.hpp
+++ b/nano/rpc/rpc_request_processor.hpp
@@ -12,7 +12,7 @@ namespace nano
 struct ipc_connection
 {
 	ipc_connection (nano::ipc::ipc_client && client_a, bool is_available_a) :
-	client (std::move (client_a)), is_available (is_available_a)
+		client (std::move (client_a)), is_available (is_available_a)
 	{
 	}
 
@@ -22,25 +22,25 @@ struct ipc_connection
 
 struct rpc_request
 {
-	rpc_request (const std::string & action_a, const std::string & body_a, std::function<void(std::string const &)> response_a) :
-	action (action_a), body (body_a), response (response_a)
+	rpc_request (const std::string & action_a, const std::string & body_a, std::function<void (std::string const &)> response_a) :
+		action (action_a), body (body_a), response (response_a)
 	{
 	}
 
-	rpc_request (int rpc_api_version_a, const std::string & body_a, std::function<void(std::string const &)> response_a) :
-	rpc_api_version (rpc_api_version_a), body (body_a), response (response_a)
+	rpc_request (int rpc_api_version_a, const std::string & body_a, std::function<void (std::string const &)> response_a) :
+		rpc_api_version (rpc_api_version_a), body (body_a), response (response_a)
 	{
 	}
 
-	rpc_request (int rpc_api_version_a, const std::string & action_a, const std::string & body_a, std::function<void(std::string const &)> response_a) :
-	rpc_api_version (rpc_api_version_a), action (action_a), body (body_a), response (response_a)
+	rpc_request (int rpc_api_version_a, const std::string & action_a, const std::string & body_a, std::function<void (std::string const &)> response_a) :
+		rpc_api_version (rpc_api_version_a), action (action_a), body (body_a), response (response_a)
 	{
 	}
 
 	int rpc_api_version{ 1 };
 	std::string action;
 	std::string body;
-	std::function<void(std::string const &)> response;
+	std::function<void (std::string const &)> response;
 };
 
 class rpc_request_processor
@@ -50,7 +50,7 @@ class rpc_request_processor
 	~rpc_request_processor ();
 	void stop ();
 	void add (std::shared_ptr<rpc_request> const & request);
-	std::function<void()> stop_callback;
+	std::function<void ()> stop_callback;
 
 private:
 	void run ();
@@ -73,19 +73,19 @@ class ipc_rpc_processor final : public nano::rpc_handler_interface
 {
 public:
 	ipc_rpc_processor (boost::asio::io_context & io_ctx, nano::rpc_config & rpc_config) :
-	rpc_request_processor (io_ctx, rpc_config)
+		rpc_request_processor (io_ctx, rpc_config)
 	{
 	}
 
-	void process_request (std::string const & action_a, std::string const & body_a, std::function<void(std::string const &)> response_a) override
+	void process_request (std::string const & action_a, std::string const & body_a, std::function<void (std::string const &)> response_a) override
 	{
 		rpc_request_processor.add (std::make_shared<nano::rpc_request> (action_a, body_a, response_a));
 	}
 
-	void process_request_v2 (rpc_handler_request_params const & params_a, std::string const & body_a, std::function<void(std::shared_ptr<std::string> const &)> response_a) override
+	void process_request_v2 (rpc_handler_request_params const & params_a, std::string const & body_a, std::function<void (std::shared_ptr<std::string> const &)> response_a) override
 	{
 		std::string body_l = params_a.json_envelope (body_a);
-		rpc_request_processor.add (std::make_shared<nano::rpc_request> (2 /* rpc version */, body_l, [response_a](std::string const & resp) {
+		rpc_request_processor.add (std::make_shared<nano::rpc_request> (2 /* rpc version */, body_l, [response_a] (std::string const & resp) {
 			auto resp_l (std::make_shared<std::string> (resp));
 			response_a (resp_l);
 		}));
@@ -98,7 +98,7 @@ class ipc_rpc_processor final : public nano::rpc_handler_interface
 
 	void rpc_instance (nano::rpc & rpc) override
 	{
-		rpc_request_processor.stop_callback = [&rpc]() {
+		rpc_request_processor.stop_callback = [&rpc] () {
 			rpc.stop ();
 		};
 	}
diff --git a/nano/rpc/rpc_secure.cpp b/nano/rpc/rpc_secure.cpp
index 4b9cc4fcae..ba088415c1 100644
--- a/nano/rpc/rpc_secure.cpp
+++ b/nano/rpc/rpc_secure.cpp
@@ -68,7 +68,7 @@ void nano::rpc_secure::load_certs (boost::asio::ssl::context & context_a)
 	{
 		// This is called if the key is password protected
 		context_a.set_password_callback (
-		[this](std::size_t,
+		[this] (std::size_t,
 		boost::asio::ssl::context_base::password_purpose) {
 			return config.secure.server_key_passphrase;
 		});
@@ -90,7 +90,7 @@ void nano::rpc_secure::load_certs (boost::asio::ssl::context & context_a)
 		{
 			context_a.set_verify_mode (boost::asio::ssl::verify_fail_if_no_peer_cert | boost::asio::ssl::verify_peer);
 			context_a.add_verify_path (config.secure.client_certs_path);
-			context_a.set_verify_callback ([this](auto preverified, auto & ctx) {
+			context_a.set_verify_callback ([this] (auto preverified, auto & ctx) {
 				return this->on_verify_certificate (preverified, ctx);
 			});
 		}
@@ -104,8 +104,8 @@ void nano::rpc_secure::load_certs (boost::asio::ssl::context & context_a)
 }
 
 nano::rpc_secure::rpc_secure (boost::asio::io_context & context_a, nano::rpc_config const & config_a, nano::rpc_handler_interface & rpc_handler_interface_a) :
-rpc (context_a, config_a, rpc_handler_interface_a),
-ssl_context (boost::asio::ssl::context::tlsv12_server)
+	rpc (context_a, config_a, rpc_handler_interface_a),
+	ssl_context (boost::asio::ssl::context::tlsv12_server)
 {
 	load_certs (ssl_context);
 }
@@ -113,7 +113,7 @@ ssl_context (boost::asio::ssl::context::tlsv12_server)
 void nano::rpc_secure::accept ()
 {
 	auto connection (std::make_shared<nano::rpc_connection_secure> (config, io_ctx, logger, rpc_handler_interface, this->ssl_context));
-	acceptor.async_accept (connection->socket, boost::asio::bind_executor (connection->strand, [this, connection](boost::system::error_code const & ec) {
+	acceptor.async_accept (connection->socket, boost::asio::bind_executor (connection->strand, [this, connection] (boost::system::error_code const & ec) {
 		if (ec != boost::asio::error::operation_aborted && acceptor.is_open ())
 		{
 			accept ();
diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp
index 4a41ce14e2..3ef4a48e3c 100644
--- a/nano/rpc_test/rpc.cpp
+++ b/nano/rpc_test/rpc.cpp
@@ -26,14 +26,14 @@ class test_response
 {
 public:
 	test_response (boost::property_tree::ptree const & request_a, boost::asio::io_context & io_ctx_a) :
-	request (request_a),
-	sock (io_ctx_a)
+		request (request_a),
+		sock (io_ctx_a)
 	{
 	}
 
 	test_response (boost::property_tree::ptree const & request_a, uint16_t port_a, boost::asio::io_context & io_ctx_a) :
-	request (request_a),
-	sock (io_ctx_a)
+		request (request_a),
+		sock (io_ctx_a)
 	{
 		run (port_a);
 	}
@@ -188,14 +188,14 @@ TEST (rpc, account_balance)
 	nano::state_block_builder builder;
 
 	auto send1 = builder.make_block ()
-	             .account (nano::dev_genesis_key.pub)
-	             .previous (nano::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))
-	             .build ();
+				 .account (nano::dev_genesis_key.pub)
+				 .previous (nano::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))
+				 .build ();
 
 	ASSERT_EQ (nano::process_result::progress, node->process (*send1).code);
 
diff --git a/nano/secure/blockstore.cpp b/nano/secure/blockstore.cpp
index 9299b4166d..4431eccdb6 100644
--- a/nano/secure/blockstore.cpp
+++ b/nano/secure/blockstore.cpp
@@ -2,9 +2,9 @@
 #include <nano/secure/blockstore.hpp>
 
 nano::representative_visitor::representative_visitor (nano::transaction const & transaction_a, nano::block_store & store_a) :
-transaction (transaction_a),
-store (store_a),
-result (0)
+	transaction (transaction_a),
+	store (store_a),
+	result (0)
 {
 }
 
@@ -45,7 +45,7 @@ void nano::representative_visitor::state_block (nano::state_block const & block_
 }
 
 nano::read_transaction::read_transaction (std::unique_ptr<nano::read_transaction_impl> read_transaction_impl) :
-impl (std::move (read_transaction_impl))
+	impl (std::move (read_transaction_impl))
 {
 }
 
@@ -71,7 +71,7 @@ void nano::read_transaction::refresh () const
 }
 
 nano::write_transaction::write_transaction (std::unique_ptr<nano::write_transaction_impl> write_transaction_impl) :
-impl (std::move (write_transaction_impl))
+	impl (std::move (write_transaction_impl))
 {
 	/*
 	 * For IO threads, we do not want them to block on creating write transactions.
diff --git a/nano/secure/blockstore.hpp b/nano/secure/blockstore.hpp
index ba99b9d42b..9581a95d51 100644
--- a/nano/secure/blockstore.hpp
+++ b/nano/secure/blockstore.hpp
@@ -41,70 +41,70 @@ class db_val
 {
 public:
 	db_val (Val const & value_a) :
-	value (value_a)
+		value (value_a)
 	{
 	}
 
 	db_val () :
-	db_val (0, nullptr)
+		db_val (0, nullptr)
 	{
 	}
 
 	db_val (std::nullptr_t) :
-	db_val (0, this)
+		db_val (0, this)
 	{
 	}
 
 	db_val (nano::uint128_union const & val_a) :
-	db_val (sizeof (val_a), const_cast<nano::uint128_union *> (&val_a))
+		db_val (sizeof (val_a), const_cast<nano::uint128_union *> (&val_a))
 	{
 	}
 
 	db_val (nano::uint256_union const & val_a) :
-	db_val (sizeof (val_a), const_cast<nano::uint256_union *> (&val_a))
+		db_val (sizeof (val_a), const_cast<nano::uint256_union *> (&val_a))
 	{
 	}
 
 	db_val (nano::uint512_union const & val_a) :
-	db_val (sizeof (val_a), const_cast<nano::uint512_union *> (&val_a))
+		db_val (sizeof (val_a), const_cast<nano::uint512_union *> (&val_a))
 	{
 	}
 
 	db_val (nano::qualified_root const & val_a) :
-	db_val (sizeof (val_a), const_cast<nano::qualified_root *> (&val_a))
+		db_val (sizeof (val_a), const_cast<nano::qualified_root *> (&val_a))
 	{
 	}
 
 	db_val (nano::account_info const & val_a) :
-	db_val (val_a.db_size (), const_cast<nano::account_info *> (&val_a))
+		db_val (val_a.db_size (), const_cast<nano::account_info *> (&val_a))
 	{
 	}
 
 	db_val (nano::account_info_v14 const & val_a) :
-	db_val (val_a.db_size (), const_cast<nano::account_info_v14 *> (&val_a))
+		db_val (val_a.db_size (), const_cast<nano::account_info_v14 *> (&val_a))
 	{
 	}
 
 	db_val (nano::pending_info const & val_a) :
-	db_val (val_a.db_size (), const_cast<nano::pending_info *> (&val_a))
+		db_val (val_a.db_size (), const_cast<nano::pending_info *> (&val_a))
 	{
 		static_assert (std::is_standard_layout<nano::pending_info>::value, "Standard layout is required");
 	}
 
 	db_val (nano::pending_info_v14 const & val_a) :
-	db_val (val_a.db_size (), const_cast<nano::pending_info_v14 *> (&val_a))
+		db_val (val_a.db_size (), const_cast<nano::pending_info_v14 *> (&val_a))
 	{
 		static_assert (std::is_standard_layout<nano::pending_info_v14>::value, "Standard layout is required");
 	}
 
 	db_val (nano::pending_key const & val_a) :
-	db_val (sizeof (val_a), const_cast<nano::pending_key *> (&val_a))
+		db_val (sizeof (val_a), const_cast<nano::pending_key *> (&val_a))
 	{
 		static_assert (std::is_standard_layout<nano::pending_key>::value, "Standard layout is required");
 	}
 
 	db_val (nano::unchecked_info const & val_a) :
-	buffer (std::make_shared<std::vector<uint8_t>> ())
+		buffer (std::make_shared<std::vector<uint8_t>> ())
 	{
 		{
 			nano::vectorstream stream (*buffer);
@@ -114,13 +114,13 @@ class db_val
 	}
 
 	db_val (nano::unchecked_key const & val_a) :
-	db_val (sizeof (val_a), const_cast<nano::unchecked_key *> (&val_a))
+		db_val (sizeof (val_a), const_cast<nano::unchecked_key *> (&val_a))
 	{
 		static_assert (std::is_standard_layout<nano::unchecked_key>::value, "Standard layout is required");
 	}
 
 	db_val (nano::confirmation_height_info const & val_a) :
-	buffer (std::make_shared<std::vector<uint8_t>> ())
+		buffer (std::make_shared<std::vector<uint8_t>> ())
 	{
 		{
 			nano::vectorstream stream (*buffer);
@@ -130,19 +130,19 @@ class db_val
 	}
 
 	db_val (nano::block_info const & val_a) :
-	db_val (sizeof (val_a), const_cast<nano::block_info *> (&val_a))
+		db_val (sizeof (val_a), const_cast<nano::block_info *> (&val_a))
 	{
 		static_assert (std::is_standard_layout<nano::block_info>::value, "Standard layout is required");
 	}
 
 	db_val (nano::endpoint_key const & val_a) :
-	db_val (sizeof (val_a), const_cast<nano::endpoint_key *> (&val_a))
+		db_val (sizeof (val_a), const_cast<nano::endpoint_key *> (&val_a))
 	{
 		static_assert (std::is_standard_layout<nano::endpoint_key>::value, "Standard layout is required");
 	}
 
 	db_val (std::shared_ptr<nano::block> const & val_a) :
-	buffer (std::make_shared<std::vector<uint8_t>> ())
+		buffer (std::make_shared<std::vector<uint8_t>> ())
 	{
 		{
 			nano::vectorstream stream (*buffer);
@@ -152,7 +152,7 @@ class db_val
 	}
 
 	db_val (uint64_t val_a) :
-	buffer (std::make_shared<std::vector<uint8_t>> ())
+		buffer (std::make_shared<std::vector<uint8_t>> ())
 	{
 		{
 			boost::endian::native_to_big_inplace (val_a);
@@ -490,13 +490,13 @@ class store_iterator final
 	{
 	}
 	store_iterator (std::unique_ptr<nano::store_iterator_impl<T, U>> impl_a) :
-	impl (std::move (impl_a))
+		impl (std::move (impl_a))
 	{
 		impl->fill (current);
 	}
 	store_iterator (nano::store_iterator<T, U> && other_a) :
-	current (std::move (other_a.current)),
-	impl (std::move (other_a.impl))
+		current (std::move (other_a.current)),
+		impl (std::move (other_a.impl))
 	{
 	}
 	nano::store_iterator<T, U> & operator++ ()
@@ -727,14 +727,14 @@ class block_store
 	virtual nano::store_iterator<nano::account, nano::confirmation_height_info> confirmation_height_begin (nano::transaction const & transaction_a) const = 0;
 	virtual nano::store_iterator<nano::account, nano::confirmation_height_info> confirmation_height_end () const = 0;
 
-	virtual void accounts_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::account, nano::account_info>, nano::store_iterator<nano::account, nano::account_info>)> const &) const = 0;
-	virtual void confirmation_height_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::account, nano::confirmation_height_info>, nano::store_iterator<nano::account, nano::confirmation_height_info>)> const &) const = 0;
-	virtual void pending_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::pending_key, nano::pending_info>, nano::store_iterator<nano::pending_key, nano::pending_info>)> const & action_a) const = 0;
-	virtual void unchecked_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::unchecked_key, nano::unchecked_info>, nano::store_iterator<nano::unchecked_key, nano::unchecked_info>)> const & action_a) const = 0;
-	virtual void pruned_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::block_hash, std::nullptr_t>, nano::store_iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const = 0;
-	virtual void blocks_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::block_hash, block_w_sideband>, nano::store_iterator<nano::block_hash, block_w_sideband>)> const & action_a) const = 0;
-	virtual void frontiers_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::block_hash, nano::account>, nano::store_iterator<nano::block_hash, nano::account>)> const & action_a) const = 0;
-	virtual void final_vote_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::qualified_root, nano::block_hash>, nano::store_iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const = 0;
+	virtual void accounts_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::account, nano::account_info>, nano::store_iterator<nano::account, nano::account_info>)> const &) const = 0;
+	virtual void confirmation_height_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::account, nano::confirmation_height_info>, nano::store_iterator<nano::account, nano::confirmation_height_info>)> const &) const = 0;
+	virtual void pending_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::pending_key, nano::pending_info>, nano::store_iterator<nano::pending_key, nano::pending_info>)> const & action_a) const = 0;
+	virtual void unchecked_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::unchecked_key, nano::unchecked_info>, nano::store_iterator<nano::unchecked_key, nano::unchecked_info>)> const & action_a) const = 0;
+	virtual void pruned_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::block_hash, std::nullptr_t>, nano::store_iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const = 0;
+	virtual void blocks_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::block_hash, block_w_sideband>, nano::store_iterator<nano::block_hash, block_w_sideband>)> const & action_a) const = 0;
+	virtual void frontiers_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::block_hash, nano::account>, nano::store_iterator<nano::block_hash, nano::account>)> const & action_a) const = 0;
+	virtual void final_vote_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::qualified_root, nano::block_hash>, nano::store_iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const = 0;
 
 	virtual uint64_t block_account_height (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const = 0;
 
diff --git a/nano/secure/blockstore_partial.hpp b/nano/secure/blockstore_partial.hpp
index f3970e3feb..ae9f45a7af 100644
--- a/nano/secure/blockstore_partial.hpp
+++ b/nano/secure/blockstore_partial.hpp
@@ -19,7 +19,7 @@
 namespace
 {
 template <typename T>
-void parallel_traversal (std::function<void(T const &, T const &, bool const)> const & action);
+void parallel_traversal (std::function<void (T const &, T const &, bool const)> const & action);
 }
 
 namespace nano
@@ -771,28 +771,28 @@ class block_store_partial : public block_store
 		return count (transaction_a, tables::unchecked);
 	}
 
-	void accounts_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::account, nano::account_info>, nano::store_iterator<nano::account, nano::account_info>)> const & action_a) const override
+	void accounts_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::account, nano::account_info>, nano::store_iterator<nano::account, nano::account_info>)> const & action_a) const override
 	{
 		parallel_traversal<nano::uint256_t> (
-		[&action_a, this](nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
+		[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
 			auto transaction (this->tx_begin_read ());
 			action_a (transaction, this->accounts_begin (transaction, start), !is_last ? this->accounts_begin (transaction, end) : this->accounts_end ());
 		});
 	}
 
-	void confirmation_height_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::account, nano::confirmation_height_info>, nano::store_iterator<nano::account, nano::confirmation_height_info>)> const & action_a) const override
+	void confirmation_height_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::account, nano::confirmation_height_info>, nano::store_iterator<nano::account, nano::confirmation_height_info>)> const & action_a) const override
 	{
 		parallel_traversal<nano::uint256_t> (
-		[&action_a, this](nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
+		[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
 			auto transaction (this->tx_begin_read ());
 			action_a (transaction, this->confirmation_height_begin (transaction, start), !is_last ? this->confirmation_height_begin (transaction, end) : this->confirmation_height_end ());
 		});
 	}
 
-	void pending_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::pending_key, nano::pending_info>, nano::store_iterator<nano::pending_key, nano::pending_info>)> const & action_a) const override
+	void pending_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::pending_key, nano::pending_info>, nano::store_iterator<nano::pending_key, nano::pending_info>)> const & action_a) const override
 	{
 		parallel_traversal<nano::uint512_t> (
-		[&action_a, this](nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) {
+		[&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) {
 			nano::uint512_union union_start (start);
 			nano::uint512_union union_end (end);
 			nano::pending_key key_start (union_start.uint256s[0].number (), union_start.uint256s[1].number ());
@@ -802,10 +802,10 @@ class block_store_partial : public block_store
 		});
 	}
 
-	void unchecked_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::unchecked_key, nano::unchecked_info>, nano::store_iterator<nano::unchecked_key, nano::unchecked_info>)> const & action_a) const override
+	void unchecked_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::unchecked_key, nano::unchecked_info>, nano::store_iterator<nano::unchecked_key, nano::unchecked_info>)> const & action_a) const override
 	{
 		parallel_traversal<nano::uint512_t> (
-		[&action_a, this](nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) {
+		[&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) {
 			nano::unchecked_key key_start (start);
 			nano::unchecked_key key_end (end);
 			auto transaction (this->tx_begin_read ());
@@ -813,37 +813,37 @@ class block_store_partial : public block_store
 		});
 	}
 
-	void blocks_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::block_hash, block_w_sideband>, nano::store_iterator<nano::block_hash, block_w_sideband>)> const & action_a) const override
+	void blocks_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::block_hash, block_w_sideband>, nano::store_iterator<nano::block_hash, block_w_sideband>)> const & action_a) const override
 	{
 		parallel_traversal<nano::uint256_t> (
-		[&action_a, this](nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
+		[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
 			auto transaction (this->tx_begin_read ());
 			action_a (transaction, this->blocks_begin (transaction, start), !is_last ? this->blocks_begin (transaction, end) : this->blocks_end ());
 		});
 	}
 
-	void pruned_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::block_hash, std::nullptr_t>, nano::store_iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const override
+	void pruned_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::block_hash, std::nullptr_t>, nano::store_iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const override
 	{
 		parallel_traversal<nano::uint256_t> (
-		[&action_a, this](nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
+		[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
 			auto transaction (this->tx_begin_read ());
 			action_a (transaction, this->pruned_begin (transaction, start), !is_last ? this->pruned_begin (transaction, end) : this->pruned_end ());
 		});
 	}
 
-	void frontiers_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::block_hash, nano::account>, nano::store_iterator<nano::block_hash, nano::account>)> const & action_a) const override
+	void frontiers_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::block_hash, nano::account>, nano::store_iterator<nano::block_hash, nano::account>)> const & action_a) const override
 	{
 		parallel_traversal<nano::uint256_t> (
-		[&action_a, this](nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
+		[&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) {
 			auto transaction (this->tx_begin_read ());
 			action_a (transaction, this->frontiers_begin (transaction, start), !is_last ? this->frontiers_begin (transaction, end) : this->frontiers_end ());
 		});
 	}
 
-	void final_vote_for_each_par (std::function<void(nano::read_transaction const &, nano::store_iterator<nano::qualified_root, nano::block_hash>, nano::store_iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const override
+	void final_vote_for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::qualified_root, nano::block_hash>, nano::store_iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const override
 	{
 		parallel_traversal<nano::uint512_t> (
-		[&action_a, this](nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) {
+		[&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) {
 			auto transaction (this->tx_begin_read ());
 			action_a (transaction, this->final_vote_begin (transaction, start), !is_last ? this->final_vote_begin (transaction, end) : this->final_vote_end ());
 		});
@@ -933,8 +933,8 @@ class block_predecessor_set : public nano::block_visitor
 {
 public:
 	block_predecessor_set (nano::write_transaction const & transaction_a, nano::block_store_partial<Val, Derived_Store> & store_a) :
-	transaction (transaction_a),
-	store (store_a)
+		transaction (transaction_a),
+		store (store_a)
 	{
 	}
 	virtual ~block_predecessor_set () = default;
@@ -979,7 +979,7 @@ class block_predecessor_set : public nano::block_visitor
 namespace
 {
 template <typename T>
-void parallel_traversal (std::function<void(T const &, T const &, bool const)> const & action)
+void parallel_traversal (std::function<void (T const &, T const &, bool const)> const & action)
 {
 	// Between 10 and 40 threads, scales well even in low power systems as long as actions are I/O bound
 	unsigned const thread_count = std::max (10u, std::min (40u, 10 * std::thread::hardware_concurrency ()));
diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp
index d16516b725..f75eaa290c 100644
--- a/nano/secure/common.cpp
+++ b/nano/secure/common.cpp
@@ -76,12 +76,12 @@ std::shared_ptr<nano::block> parse_block_from_genesis_data (std::string const &
 }
 
 nano::network_params::network_params () :
-network_params (network_constants::active_network)
+	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)
+	network (network_a), ledger (network), voting (network), node (network), portmapping (network), bootstrap (network)
 {
 	unsigned constexpr kdf_full_work = 64 * 1024;
 	unsigned constexpr kdf_dev_work = 8;
@@ -95,26 +95,26 @@ uint8_t nano::protocol_constants::protocol_version_min () const
 }
 
 nano::ledger_constants::ledger_constants (nano::network_constants & network_constants) :
-ledger_constants (network_constants.network ())
+	ledger_constants (network_constants.network ())
 {
 }
 
 nano::ledger_constants::ledger_constants (nano::nano_networks network_a) :
-zero_key ("0"),
-dev_genesis_key (dev_private_key_data),
-nano_dev_account (dev_public_key_data),
-nano_beta_account (beta_public_key_data),
-nano_live_account (live_public_key_data),
-nano_test_account (test_public_key_data),
-nano_dev_genesis (dev_genesis_data),
-nano_beta_genesis (beta_genesis_data),
-nano_live_genesis (live_genesis_data),
-nano_test_genesis (test_genesis_data),
-genesis_account (network_a == nano::nano_networks::nano_dev_network ? nano_dev_account : network_a == nano::nano_networks::nano_beta_network ? nano_beta_account : network_a == nano::nano_networks::nano_test_network ? nano_test_account : nano_live_account),
-genesis_block (network_a == nano::nano_networks::nano_dev_network ? nano_dev_genesis : network_a == nano::nano_networks::nano_beta_network ? nano_beta_genesis : network_a == nano::nano_networks::nano_test_network ? nano_test_genesis : nano_live_genesis),
-genesis_hash (parse_block_from_genesis_data (genesis_block)->hash ()),
-genesis_amount (std::numeric_limits<nano::uint128_t>::max ()),
-burn_account (0)
+	zero_key ("0"),
+	dev_genesis_key (dev_private_key_data),
+	nano_dev_account (dev_public_key_data),
+	nano_beta_account (beta_public_key_data),
+	nano_live_account (live_public_key_data),
+	nano_test_account (test_public_key_data),
+	nano_dev_genesis (dev_genesis_data),
+	nano_beta_genesis (beta_genesis_data),
+	nano_live_genesis (live_genesis_data),
+	nano_test_genesis (test_genesis_data),
+	genesis_account (network_a == nano::nano_networks::nano_dev_network ? nano_dev_account : network_a == nano::nano_networks::nano_beta_network ? nano_beta_account : network_a == nano::nano_networks::nano_test_network ? nano_test_account : nano_live_account),
+	genesis_block (network_a == nano::nano_networks::nano_dev_network ? nano_dev_genesis : network_a == nano::nano_networks::nano_beta_network ? nano_beta_genesis : network_a == nano::nano_networks::nano_test_network ? nano_test_genesis : nano_live_genesis),
+	genesis_hash (parse_block_from_genesis_data (genesis_block)->hash ()),
+	genesis_amount (std::numeric_limits<nano::uint128_t>::max ()),
+	burn_account (0)
 {
 	nano::link epoch_link_v1;
 	const char * epoch_message_v1 ("epoch v1 block");
@@ -156,8 +156,8 @@ nano::node_constants::node_constants (nano::network_constants & network_constant
 }
 
 nano::voting_constants::voting_constants (nano::network_constants & network_constants) :
-max_cache{ network_constants.is_dev_network () ? 256U : 128U * 1024 },
-delay{ network_constants.is_dev_network () ? 1 : 15 }
+	max_cache{ network_constants.is_dev_network () ? 256U : 128U * 1024 },
+	delay{ network_constants.is_dev_network () ? 1 : 15 }
 {
 }
 
@@ -187,7 +187,7 @@ nano::keypair::keypair ()
 
 // Create a keypair given a private key
 nano::keypair::keypair (nano::raw_key && prv_a) :
-prv (std::move (prv_a))
+	prv (std::move (prv_a))
 {
 	ed25519_publickey (prv.bytes.data (), pub.bytes.data ());
 }
@@ -208,13 +208,13 @@ void nano::serialize_block (nano::stream & stream_a, nano::block const & block_a
 }
 
 nano::account_info::account_info (nano::block_hash const & head_a, nano::account const & representative_a, nano::block_hash const & open_block_a, nano::amount const & balance_a, uint64_t modified_a, uint64_t block_count_a, nano::epoch epoch_a) :
-head (head_a),
-representative (representative_a),
-open_block (open_block_a),
-balance (balance_a),
-modified (modified_a),
-block_count (block_count_a),
-epoch_m (epoch_a)
+	head (head_a),
+	representative (representative_a),
+	open_block (open_block_a),
+	balance (balance_a),
+	modified (modified_a),
+	block_count (block_count_a),
+	epoch_m (epoch_a)
 {
 }
 
@@ -267,9 +267,9 @@ nano::epoch nano::account_info::epoch () const
 }
 
 nano::pending_info::pending_info (nano::account const & source_a, nano::amount const & amount_a, nano::epoch epoch_a) :
-source (source_a),
-amount (amount_a),
-epoch (epoch_a)
+	source (source_a),
+	amount (amount_a),
+	epoch (epoch_a)
 {
 }
 
@@ -301,8 +301,8 @@ bool nano::pending_info::operator== (nano::pending_info const & other_a) const
 }
 
 nano::pending_key::pending_key (nano::account const & account_a, nano::block_hash const & hash_a) :
-account (account_a),
-hash (hash_a)
+	account (account_a),
+	hash (hash_a)
 {
 }
 
@@ -333,11 +333,11 @@ nano::account const & nano::pending_key::key () const
 }
 
 nano::unchecked_info::unchecked_info (std::shared_ptr<nano::block> const & block_a, nano::account const & account_a, uint64_t modified_a, nano::signature_verification verified_a, bool confirmed_a) :
-block (block_a),
-account (account_a),
-modified (modified_a),
-verified (verified_a),
-confirmed (confirmed_a)
+	block (block_a),
+	account (account_a),
+	modified (modified_a),
+	verified (verified_a),
+	confirmed (confirmed_a)
 {
 }
 
@@ -371,7 +371,7 @@ bool nano::unchecked_info::deserialize (nano::stream & stream_a)
 }
 
 nano::endpoint_key::endpoint_key (const std::array<uint8_t, 16> & address_a, uint16_t port_a) :
-address (address_a), network_port (boost::endian::native_to_big (port_a))
+	address (address_a), network_port (boost::endian::native_to_big (port_a))
 {
 }
 
@@ -386,8 +386,8 @@ uint16_t nano::endpoint_key::port () const
 }
 
 nano::confirmation_height_info::confirmation_height_info (uint64_t confirmation_height_a, nano::block_hash const & confirmed_frontier_a) :
-height (confirmation_height_a),
-frontier (confirmed_frontier_a)
+	height (confirmation_height_a),
+	frontier (confirmed_frontier_a)
 {
 }
 
@@ -413,8 +413,8 @@ bool nano::confirmation_height_info::deserialize (nano::stream & stream_a)
 }
 
 nano::block_info::block_info (nano::account const & account_a, nano::amount const & balance_a) :
-account (account_a),
-balance (balance_a)
+	account (account_a),
+	balance (balance_a)
 {
 }
 
@@ -492,10 +492,10 @@ std::string nano::vote::to_json () const
 }
 
 nano::vote::vote (nano::vote const & other_a) :
-timestamp{ other_a.timestamp },
-blocks (other_a.blocks),
-account (other_a.account),
-signature (other_a.signature)
+	timestamp{ other_a.timestamp },
+	blocks (other_a.blocks),
+	account (other_a.account),
+	signature (other_a.signature)
 {
 }
 
@@ -543,16 +543,16 @@ nano::vote::vote (bool & error_a, nano::stream & stream_a, nano::block_type type
 }
 
 nano::vote::vote (nano::account const & account_a, nano::raw_key const & prv_a, uint64_t timestamp_a, std::shared_ptr<nano::block> const & block_a) :
-timestamp{ timestamp_a },
-blocks (1, block_a),
-account (account_a),
-signature (nano::sign_message (prv_a, account_a, hash ()))
+	timestamp{ timestamp_a },
+	blocks (1, block_a),
+	account (account_a),
+	signature (nano::sign_message (prv_a, account_a, hash ()))
 {
 }
 
 nano::vote::vote (nano::account const & account_a, nano::raw_key const & prv_a, uint64_t timestamp_a, std::vector<nano::block_hash> const & blocks_a) :
-timestamp{ timestamp_a },
-account (account_a)
+	timestamp{ timestamp_a },
+	account (account_a)
 {
 	debug_assert (!blocks_a.empty ());
 	debug_assert (blocks_a.size () <= 12);
@@ -735,7 +735,7 @@ boost::transform_iterator<nano::iterate_vote_blocks_as_hash, nano::vote_blocks_v
 }
 
 nano::vote_uniquer::vote_uniquer (nano::block_uniquer & uniquer_a) :
-uniquer (uniquer_a)
+	uniquer (uniquer_a)
 {
 }
 
@@ -823,14 +823,14 @@ nano::wallet_id nano::random_wallet_id ()
 }
 
 nano::unchecked_key::unchecked_key (nano::hash_or_account const & previous_a, nano::block_hash const & hash_a) :
-previous (previous_a.hash),
-hash (hash_a)
+	previous (previous_a.hash),
+	hash (hash_a)
 {
 }
 
 nano::unchecked_key::unchecked_key (nano::uint512_union const & union_a) :
-previous (union_a.uint256s[0].number ()),
-hash (union_a.uint256s[1].number ())
+	previous (union_a.uint256s[0].number ()),
+	hash (union_a.uint256s[1].number ())
 {
 }
 
diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp
index 12ce86efa1..abf473faa8 100644
--- a/nano/secure/ledger.cpp
+++ b/nano/secure/ledger.cpp
@@ -17,9 +17,9 @@ class rollback_visitor : public nano::block_visitor
 {
 public:
 	rollback_visitor (nano::write_transaction const & transaction_a, nano::ledger & ledger_a, std::vector<std::shared_ptr<nano::block>> & list_a) :
-	transaction (transaction_a),
-	ledger (ledger_a),
-	list (list_a)
+		transaction (transaction_a),
+		ledger (ledger_a),
+		list (list_a)
 	{
 	}
 	virtual ~rollback_visitor () = default;
@@ -728,18 +728,18 @@ void ledger_processor::open_block (nano::open_block & block_a)
 }
 
 ledger_processor::ledger_processor (nano::ledger & ledger_a, nano::write_transaction const & transaction_a, nano::signature_verification verification_a) :
-ledger (ledger_a),
-transaction (transaction_a),
-verification (verification_a)
+	ledger (ledger_a),
+	transaction (transaction_a),
+	verification (verification_a)
 {
 	result.verified = verification;
 }
 } // namespace
 
 nano::ledger::ledger (nano::block_store & store_a, nano::stat & stat_a, nano::generate_cache const & generate_cache_a) :
-store (store_a),
-stats (stat_a),
-check_bootstrap_weights (true)
+	store (store_a),
+	stats (stat_a),
+	check_bootstrap_weights (true)
 {
 	if (!store.init_error ())
 	{
@@ -1182,9 +1182,9 @@ class dependent_block_visitor : public nano::block_visitor
 {
 public:
 	dependent_block_visitor (nano::ledger const & ledger_a, nano::transaction const & transaction_a) :
-	ledger (ledger_a),
-	transaction (transaction_a),
-	result ({ 0, 0 })
+		ledger (ledger_a),
+		transaction (transaction_a),
+		result ({ 0, 0 })
 	{
 	}
 	void send_block (nano::send_block const & block_a) override
@@ -1538,7 +1538,7 @@ bool nano::ledger::migrate_lmdb_to_rocksdb (boost::filesystem::path const & data
 }
 
 nano::uncemented_info::uncemented_info (nano::block_hash const & cemented_frontier, nano::block_hash const & frontier, nano::account const & account) :
-cemented_frontier (cemented_frontier), frontier (frontier), account (account)
+	cemented_frontier (cemented_frontier), frontier (frontier), account (account)
 {
 }
 
diff --git a/nano/secure/network_filter.cpp b/nano/secure/network_filter.cpp
index 0bc98ae503..e48a61f975 100644
--- a/nano/secure/network_filter.cpp
+++ b/nano/secure/network_filter.cpp
@@ -5,7 +5,7 @@
 #include <nano/secure/network_filter.hpp>
 
 nano::network_filter::network_filter (size_t size_a) :
-items (size_a, nano::uint128_t{ 0 })
+	items (size_a, nano::uint128_t{ 0 })
 {
 	nano::random_pool::generate_block (key, key.size ());
 }
diff --git a/nano/secure/utility.cpp b/nano/secure/utility.cpp
index cdd666f0ef..93a355b91a 100644
--- a/nano/secure/utility.cpp
+++ b/nano/secure/utility.cpp
@@ -88,7 +88,7 @@ void nano::remove_temporary_directories ()
 namespace nano
 {
 /** A wrapper for handling signals */
-std::function<void()> signal_handler_impl;
+std::function<void ()> signal_handler_impl;
 void signal_handler (int sig)
 {
 	if (signal_handler_impl != nullptr)
diff --git a/nano/secure/utility.hpp b/nano/secure/utility.hpp
index 0644b650d7..0d090e5d81 100644
--- a/nano/secure/utility.hpp
+++ b/nano/secure/utility.hpp
@@ -14,6 +14,6 @@ boost::filesystem::path unique_path ();
 // Remove all unique tmp directories created by the process
 void remove_temporary_directories ();
 // Generic signal handler declarations
-extern std::function<void()> signal_handler_impl;
+extern std::function<void ()> signal_handler_impl;
 void signal_handler (int sig);
 }
diff --git a/nano/secure/versioning.cpp b/nano/secure/versioning.cpp
index 7de2f97c2f..11d3a6b631 100644
--- a/nano/secure/versioning.cpp
+++ b/nano/secure/versioning.cpp
@@ -5,9 +5,9 @@
 #include <lmdb/libraries/liblmdb/lmdb.h>
 
 nano::pending_info_v14::pending_info_v14 (nano::account const & source_a, nano::amount const & amount_a, nano::epoch epoch_a) :
-source (source_a),
-amount (amount_a),
-epoch (epoch_a)
+	source (source_a),
+	amount (amount_a),
+	epoch (epoch_a)
 {
 }
 
@@ -38,14 +38,14 @@ bool nano::pending_info_v14::operator== (nano::pending_info_v14 const & other_a)
 }
 
 nano::account_info_v14::account_info_v14 (nano::block_hash const & head_a, nano::block_hash const & rep_block_a, nano::block_hash const & open_block_a, nano::amount const & balance_a, uint64_t modified_a, uint64_t block_count_a, uint64_t confirmation_height_a, nano::epoch epoch_a) :
-head (head_a),
-rep_block (rep_block_a),
-open_block (open_block_a),
-balance (balance_a),
-modified (modified_a),
-block_count (block_count_a),
-confirmation_height (confirmation_height_a),
-epoch (epoch_a)
+	head (head_a),
+	rep_block (rep_block_a),
+	open_block (open_block_a),
+	balance (balance_a),
+	modified (modified_a),
+	block_count (block_count_a),
+	confirmation_height (confirmation_height_a),
+	epoch (epoch_a)
 {
 }
 
@@ -62,12 +62,12 @@ size_t nano::account_info_v14::db_size () const
 }
 
 nano::block_sideband_v14::block_sideband_v14 (nano::block_type type_a, nano::account const & account_a, nano::block_hash const & successor_a, nano::amount const & balance_a, uint64_t height_a, uint64_t timestamp_a) :
-type (type_a),
-successor (successor_a),
-account (account_a),
-balance (balance_a),
-height (height_a),
-timestamp (timestamp_a)
+	type (type_a),
+	successor (successor_a),
+	account (account_a),
+	balance (balance_a),
+	height (height_a),
+	timestamp (timestamp_a)
 {
 }
 
@@ -144,22 +144,22 @@ bool nano::block_sideband_v14::deserialize (nano::stream & stream_a)
 }
 
 nano::block_sideband_v18::block_sideband_v18 (nano::account const & account_a, nano::block_hash const & successor_a, nano::amount const & balance_a, uint64_t height_a, uint64_t timestamp_a, nano::block_details const & details_a) :
-successor (successor_a),
-account (account_a),
-balance (balance_a),
-height (height_a),
-timestamp (timestamp_a),
-details (details_a)
+	successor (successor_a),
+	account (account_a),
+	balance (balance_a),
+	height (height_a),
+	timestamp (timestamp_a),
+	details (details_a)
 {
 }
 
 nano::block_sideband_v18::block_sideband_v18 (nano::account const & account_a, nano::block_hash const & successor_a, nano::amount const & balance_a, uint64_t height_a, uint64_t timestamp_a, nano::epoch epoch_a, bool is_send, bool is_receive, bool is_epoch) :
-successor (successor_a),
-account (account_a),
-balance (balance_a),
-height (height_a),
-timestamp (timestamp_a),
-details (epoch_a, is_send, is_receive, is_epoch)
+	successor (successor_a),
+	account (account_a),
+	balance (balance_a),
+	height (height_a),
+	timestamp (timestamp_a),
+	details (epoch_a, is_send, is_receive, is_epoch)
 {
 }
 
diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp
index 8a8a4f24da..cd6ba78a0c 100644
--- a/nano/slow_test/node.cpp
+++ b/nano/slow_test/node.cpp
@@ -1609,14 +1609,14 @@ TEST (node, mass_epoch_upgrader)
 				nano::state_block_builder builder;
 				std::error_code ec;
 				auto block = builder
-				             .account (nano::dev_genesis_key.pub)
-				             .previous (latest)
-				             .balance (balance)
-				             .link (info.key.pub)
-				             .representative (nano::dev_genesis_key.pub)
-				             .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-				             .work (*node.work_generate_blocking (latest, nano::work_threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_0, false, false, false))))
-				             .build (ec);
+							 .account (nano::dev_genesis_key.pub)
+							 .previous (latest)
+							 .balance (balance)
+							 .link (info.key.pub)
+							 .representative (nano::dev_genesis_key.pub)
+							 .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+							 .work (*node.work_generate_blocking (latest, nano::work_threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_0, false, false, false))))
+							 .build (ec);
 				ASSERT_FALSE (ec);
 				ASSERT_NE (nullptr, block);
 				ASSERT_EQ (nano::process_result::progress, node.process (*block).code);
@@ -1633,14 +1633,14 @@ TEST (node, mass_epoch_upgrader)
 			nano::state_block_builder builder;
 			std::error_code ec;
 			auto block = builder
-			             .account (info.key.pub)
-			             .previous (0)
-			             .balance (amount)
-			             .link (info.pending_hash)
-			             .representative (info.key.pub)
-			             .sign (info.key.prv, info.key.pub)
-			             .work (*node.work_generate_blocking (info.key.pub, nano::work_threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_0, false, false, false))))
-			             .build (ec);
+						 .account (info.key.pub)
+						 .previous (0)
+						 .balance (amount)
+						 .link (info.pending_hash)
+						 .representative (info.key.pub)
+						 .sign (info.key.prv, info.key.pub)
+						 .work (*node.work_generate_blocking (info.key.pub, nano::work_threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_0, false, false, false))))
+						 .build (ec);
 			ASSERT_FALSE (ec);
 			ASSERT_NE (nullptr, block);
 			ASSERT_EQ (nano::process_result::progress, node.process (*block).code);
@@ -1735,14 +1735,14 @@ TEST (node, mass_block_new)
 	for (auto i = 0; i < num_blocks; ++i)
 	{
 		auto send = builder.make_block ()
-		            .account (nano::dev_genesis_key.pub)
-		            .previous (latest_genesis)
-		            .balance (nano::genesis_amount - i - 1)
-		            .representative (nano::dev_genesis_key.pub)
-		            .link (keys[i].pub)
-		            .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
-		            .work (*system.work.generate (nano::work_version::work_1, latest_genesis, send_threshold))
-		            .build ();
+					.account (nano::dev_genesis_key.pub)
+					.previous (latest_genesis)
+					.balance (nano::genesis_amount - i - 1)
+					.representative (nano::dev_genesis_key.pub)
+					.link (keys[i].pub)
+					.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
+					.work (*system.work.generate (nano::work_version::work_1, latest_genesis, send_threshold))
+					.build ();
 		latest_genesis = send->hash ();
 		send_blocks.push_back (std::move (send));
 	}
@@ -1758,14 +1758,14 @@ TEST (node, mass_block_new)
 	{
 		auto const & key = keys[i];
 		auto open = builder.make_block ()
-		            .account (key.pub)
-		            .previous (0)
-		            .balance (1)
-		            .representative (key.pub)
-		            .link (send_blocks[i]->hash ())
-		            .sign (key.prv, key.pub)
-		            .work (*system.work.generate (nano::work_version::work_1, key.pub, receive_threshold))
-		            .build ();
+					.account (key.pub)
+					.previous (0)
+					.balance (1)
+					.representative (key.pub)
+					.link (send_blocks[i]->hash ())
+					.sign (key.prv, key.pub)
+					.work (*system.work.generate (nano::work_version::work_1, key.pub, receive_threshold))
+					.build ();
 		open_blocks.push_back (std::move (open));
 	}
 	std::cout << "Open blocks built, start processing" << std::endl;
@@ -1780,14 +1780,14 @@ TEST (node, mass_block_new)
 		auto const & key = keys[i];
 		auto const & latest = open_blocks[i];
 		auto send2 = builder.make_block ()
-		             .account (key.pub)
-		             .previous (latest->hash ())
-		             .balance (0)
-		             .representative (key.pub)
-		             .link (key.pub)
-		             .sign (key.prv, key.pub)
-		             .work (*system.work.generate (nano::work_version::work_1, latest->hash (), send_threshold))
-		             .build ();
+					 .account (key.pub)
+					 .previous (latest->hash ())
+					 .balance (0)
+					 .representative (key.pub)
+					 .link (key.pub)
+					 .sign (key.prv, key.pub)
+					 .work (*system.work.generate (nano::work_version::work_1, latest->hash (), send_threshold))
+					 .build ();
 		send_blocks2.push_back (std::move (send2));
 	}
 	std::cout << "Send2 blocks built, start processing" << std::endl;
@@ -1802,14 +1802,14 @@ TEST (node, mass_block_new)
 		auto const & key = keys[i];
 		auto const & latest = send_blocks2[i];
 		auto send2 = builder.make_block ()
-		             .account (key.pub)
-		             .previous (latest->hash ())
-		             .balance (1)
-		             .representative (key.pub)
-		             .link (latest->hash ())
-		             .sign (key.prv, key.pub)
-		             .work (*system.work.generate (nano::work_version::work_1, latest->hash (), receive_threshold))
-		             .build ();
+					 .account (key.pub)
+					 .previous (latest->hash ())
+					 .balance (1)
+					 .representative (key.pub)
+					 .link (latest->hash ())
+					 .sign (key.prv, key.pub)
+					 .work (*system.work.generate (nano::work_version::work_1, latest->hash (), receive_threshold))
+					 .build ();
 		receive_blocks.push_back (std::move (send2));
 	}
 	std::cout << "Receive blocks built, start processing" << std::endl;
diff --git a/nano/test_common/network.cpp b/nano/test_common/network.cpp
index 1b546c7c29..5427ad6efa 100644
--- a/nano/test_common/network.cpp
+++ b/nano/test_common/network.cpp
@@ -16,7 +16,7 @@ std::shared_ptr<nano::transport::channel_tcp> nano::establish_tcp (nano::system
 	std::shared_ptr<nano::transport::channel_tcp> result;
 	debug_assert (!node.flags.disable_tcp_realtime);
 	std::promise<std::shared_ptr<nano::transport::channel>> promise;
-	auto callback = [&promise](std::shared_ptr<nano::transport::channel> channel_a) { promise.set_value (channel_a); };
+	auto callback = [&promise] (std::shared_ptr<nano::transport::channel> channel_a) { promise.set_value (channel_a); };
 	auto future = promise.get_future ();
 	node.network.tcp_channels.start_tcp (endpoint, callback);
 	auto error = system.poll_until_true (2s, [&future] { return future.wait_for (0s) == std::future_status::ready; });
@@ -32,9 +32,9 @@ std::shared_ptr<nano::transport::channel_tcp> nano::establish_tcp (nano::system
 	return result;
 }
 
-std::function<void(std::shared_ptr<nano::transport::channel> channel_a)> nano::keepalive_tcp_callback (nano::node & node_a)
+std::function<void (std::shared_ptr<nano::transport::channel> channel_a)> nano::keepalive_tcp_callback (nano::node & node_a)
 {
-	return [node_w = std::weak_ptr<nano::node> (node_a.shared ())](std::shared_ptr<nano::transport::channel> channel_a) {
+	return [node_w = std::weak_ptr<nano::node> (node_a.shared ())] (std::shared_ptr<nano::transport::channel> channel_a) {
 		if (auto node_l = node_w.lock ())
 		{
 			node_l->network.send_keepalive (channel_a);
diff --git a/nano/test_common/network.hpp b/nano/test_common/network.hpp
index fc9aaccc2c..cd68eba555 100644
--- a/nano/test_common/network.hpp
+++ b/nano/test_common/network.hpp
@@ -16,5 +16,5 @@ namespace transport
 std::shared_ptr<nano::transport::channel_tcp> establish_tcp (nano::system &, nano::node &, nano::endpoint const &);
 
 /** Returns a callback to be used for start_tcp to send a keepalive*/
-std::function<void(std::shared_ptr<nano::transport::channel> channel_a)> keepalive_tcp_callback (nano::node &);
+std::function<void (std::shared_ptr<nano::transport::channel> channel_a)> keepalive_tcp_callback (nano::node &);
 }
diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp
index f23bda66c5..e1298b1dd0 100644
--- a/nano/test_common/testutil.cpp
+++ b/nano/test_common/testutil.cpp
@@ -26,14 +26,14 @@ nano::account const & nano::burn_account (dev_constants.burn_account);
 
 void nano::wait_peer_connections (nano::system & system_a)
 {
-	auto wait_peer_count = [&system_a](bool in_memory) {
+	auto wait_peer_count = [&system_a] (bool in_memory) {
 		auto num_nodes = system_a.nodes.size ();
 		system_a.deadline_set (20s);
 		size_t peer_count = 0;
 		while (peer_count != num_nodes * (num_nodes - 1))
 		{
 			ASSERT_NO_ERROR (system_a.poll ());
-			peer_count = std::accumulate (system_a.nodes.cbegin (), system_a.nodes.cend (), std::size_t{ 0 }, [in_memory](auto total, auto const & node) {
+			peer_count = std::accumulate (system_a.nodes.cbegin (), system_a.nodes.cend (), std::size_t{ 0 }, [in_memory] (auto total, auto const & node) {
 				if (in_memory)
 				{
 					return total += node->network.size ();
diff --git a/nano/test_common/testutil.hpp b/nano/test_common/testutil.hpp
index f0729d6476..374c4c10b9 100644
--- a/nano/test_common/testutil.hpp
+++ b/nano/test_common/testutil.hpp
@@ -22,7 +22,7 @@
 	else                                                                                      \
 		fail (::testing::internal::GetBoolAssertionFailureMessage (                           \
 		gtest_ar_, text, actual, expected)                                                    \
-		      .c_str ())
+			  .c_str ())
 
 /** Extends gtest with a std::error_code assert that prints the error code message when non-zero */
 #define ASSERT_NO_ERROR(condition)                                                      \
@@ -95,7 +95,7 @@ class boost_log_cerr_redirect
 {
 public:
 	boost_log_cerr_redirect (std::streambuf * new_buffer) :
-	old (std::cerr.rdbuf (new_buffer))
+		old (std::cerr.rdbuf (new_buffer))
 	{
 		console_sink = (boost::log::add_console_log (std::cerr, boost::log::keywords::format = "%Message%"));
 	}
@@ -164,7 +164,7 @@ namespace util
 		 * @param required_count_a When increment() reaches this count within the deadline, await_count_for() will return false.
 		 */
 		counted_completion (unsigned required_count_a) :
-		required_count (required_count_a)
+			required_count (required_count_a)
 		{
 		}