Indeterminate vote status and enhanced websocket vote sub (#2444)

* Indeterminate vote status and enhanced websocket vote sub

* unhandled stats switch case

* disambiguate conditional expression

* Return vote_code directly from active.vote and replace tribool with simpler approach

nano/core_test/active_transactions.cpp

@@ -681,3 +681,49 @@ TEST (active_transactions, restart_dropped)
 		ASSERT_EQ (work2, block->block_work ());
 	}
 }
+
+TEST (active_transactions, vote_replays)
+{
+	nano::system system;
+	nano::node_config node_config (nano::get_available_port (), system.logging);
+	node_config.enable_voting = false;
+	auto & node = *system.add_node (node_config);
+	nano::genesis genesis;
+	nano::keypair key;
+	std::error_code ec;
+	auto send1 (std::make_shared<nano::state_block> (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, *system.work.generate (genesis.hash ())));
+	ASSERT_NE (nullptr, send1);
+	auto open1 (std::make_shared<nano::state_block> (key.pub, 0, key.pub, nano::Gxrb_ratio, send1->hash (), key.prv, key.pub, *system.work.generate (key.pub)));
+	ASSERT_NE (nullptr, open1);
+	node.process_active (send1);
+	node.process_active (open1);
+	node.block_processor.flush ();
+	ASSERT_EQ (2, node.active.size ());
+	// First vote is not a replay and confirms the election, second vote should be indeterminate since the election no longer exists
+	auto vote_send1 (std::make_shared<nano::vote> (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 0, send1));
+	ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_send1));
+	ASSERT_EQ (1, node.active.size ());
+	ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote_send1));
+	// Open new account
+	auto vote_open1 (std::make_shared<nano::vote> (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 0, open1));
+	ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_open1));
+	ASSERT_TRUE (node.active.empty ());
+	ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote_open1));
+	ASSERT_EQ (nano::Gxrb_ratio, node.ledger.weight (key.pub));
+
+	auto send2 (std::make_shared<nano::state_block> (key.pub, open1->hash (), key.pub, nano::Gxrb_ratio - 1, key.pub, key.prv, key.pub, *system.work.generate (open1->hash ())));
+	ASSERT_NE (nullptr, send2);
+	node.process_active (send2);
+	node.block_processor.flush ();
+	ASSERT_EQ (1, node.active.size ());
+	auto vote1_send2 (std::make_shared<nano::vote> (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 0, send2));
+	auto vote2_send2 (std::make_shared<nano::vote> (key.pub, key.prv, 0, send2));
+	ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote2_send2));
+	ASSERT_EQ (1, node.active.size ());
+	ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote2_send2));
+	ASSERT_EQ (1, node.active.size ());
+	ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote1_send2));
+	ASSERT_EQ (0, node.active.size ());
+	ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote1_send2));
+	ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote2_send2));
+}

nano/core_test/ledger.cpp

@@ -760,9 +760,9 @@ TEST (votes, add_one)
 	ASSERT_EQ (1, votes1->last_votes.size ());
 	lock.unlock ();
 	auto vote1 (std::make_shared<nano::vote> (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 1, send1));
-	ASSERT_FALSE (node1.active.vote (vote1));
+	ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1));
 	auto vote2 (std::make_shared<nano::vote> (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 2, send1));
-	ASSERT_FALSE (node1.active.vote (vote2));
+	ASSERT_EQ (nano::vote_code::indeterminate, node1.active.vote (vote2));
 	lock.lock ();
 	ASSERT_EQ (2, votes1->last_votes.size ());
 	auto existing1 (votes1->last_votes.find (nano::test_genesis_key.pub));
@@ -790,9 +790,9 @@ TEST (votes, add_two)
 	nano::keypair key2;
 	auto send2 (std::make_shared<nano::send_block> (genesis.hash (), key2.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0));
 	auto vote2 (std::make_shared<nano::vote> (key2.pub, key2.prv, 1, send2));
-	ASSERT_FALSE (node1.active.vote (vote2));
+	ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2));
 	auto vote1 (std::make_shared<nano::vote> (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 1, send1));
-	ASSERT_FALSE (node1.active.vote (vote1));
+	ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1));
 	lock.lock ();
 	ASSERT_EQ (3, votes1->last_votes.size ());
 	ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (nano::test_genesis_key.pub));
@@ -821,7 +821,7 @@ TEST (votes, add_existing)
 	}
 	node1.active.start (send1);
 	auto vote1 (std::make_shared<nano::vote> (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 1, send1));
-	ASSERT_FALSE (node1.active.vote (vote1));
+	ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1));
 	// Block is already processed from vote
 	ASSERT_TRUE (node1.active.publish (send1));
 	nano::unique_lock<std::mutex> lock (node1.active.mutex);
@@ -834,14 +834,14 @@ TEST (votes, add_existing)
 	// Pretend we've waited the timeout
 	votes1->last_votes[nano::test_genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20);
 	lock.unlock ();
-	ASSERT_FALSE (node1.active.vote (vote2));
+	ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2));
 	ASSERT_FALSE (node1.active.publish (send2));
 	lock.lock ();
 	ASSERT_EQ (2, votes1->last_votes[nano::test_genesis_key.pub].sequence);
 	// Also resend the old vote, and see if we respect the sequence number
 	votes1->last_votes[nano::test_genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20);
 	lock.unlock ();
-	ASSERT_TRUE (node1.active.vote (vote1));
+	ASSERT_EQ (nano::vote_code::replay, node1.active.vote (vote1));
 	lock.lock ();
 	ASSERT_EQ (2, votes1->last_votes[nano::test_genesis_key.pub].sequence);
 	ASSERT_EQ (2, votes1->last_votes.size ());

nano/core_test/node.cpp

@@ -2535,7 +2535,7 @@ TEST (node, vote_by_hash_bundle)
 	nano::keypair key1;
 	system.wallet (0)->insert_adhoc (key1.prv);
 
-	system.nodes[0]->observers.vote.add ([&max_hashes](std::shared_ptr<nano::vote> vote_a, std::shared_ptr<nano::transport::channel> channel_a) {
+	system.nodes[0]->observers.vote.add ([&max_hashes](std::shared_ptr<nano::vote> vote_a, std::shared_ptr<nano::transport::channel>, nano::vote_code) {
 		if (vote_a->blocks.size () > max_hashes)
 		{
 			max_hashes = vote_a->blocks.size ();