diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 5a973da566..d995d50f76 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -613,19 +613,19 @@ TEST (active_transactions, vote_replays) ASSERT_EQ (2, node.active.size ()); // First vote is not a replay and confirms the election, second vote should be a replay since the election has confirmed but not yet removed auto vote_send1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, send1)); - ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_send1, true)); + ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_send1)); ASSERT_EQ (2, node.active.size ()); - ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_send1, true)); + ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_send1)); // Wait until the election is removed, at which point the vote is still a replay since it's been recently confirmed ASSERT_TIMELY (3s, node.active.size () == 1); - ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_send1, true)); + ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_send1)); // Open new account auto vote_open1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, open1)); - ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_open1, true)); + ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_open1)); ASSERT_EQ (1, node.active.size ()); - ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_open1, true)); + ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_open1)); ASSERT_TIMELY (3s, node.active.empty ()); - ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_open1, true)); + ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_open1)); ASSERT_EQ (nano::Gxrb_ratio, node.ledger.weight (key.pub)); auto send2 = builder.make_block () @@ -643,27 +643,27 @@ TEST (active_transactions, vote_replays) ASSERT_EQ (1, node.active.size ()); auto vote1_send2 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, send2)); auto vote2_send2 (std::make_shared (key.pub, key.prv, 0, send2)); - ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote2_send2, true)); + 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, true)); + 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, true)); + ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote1_send2)); ASSERT_EQ (1, node.active.size ()); - ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote1_send2, true)); + ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote1_send2)); ASSERT_TIMELY (3s, node.active.empty ()); ASSERT_EQ (0, node.active.size ()); - ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote1_send2, true)); - ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote2_send2, true)); + ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote1_send2)); + ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote2_send2)); // Removing blocks as recently confirmed makes every vote indeterminate { nano::lock_guard guard (node.active.mutex); node.active.recently_confirmed.clear (); } - ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote_send1, true)); - ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote_open1, true)); - ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote1_send2, true)); - ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote2_send2, true)); + ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote_send1)); + ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote_open1)); + ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote1_send2)); + ASSERT_EQ (nano::vote_code::indeterminate, node.active.vote (vote2_send2)); } } @@ -1498,7 +1498,7 @@ TEST (active_transactions, conflicting_block_vote_existing_election) ASSERT_EQ (1, node.active.size ()); // Vote for conflicting block, but the block does not yet exist in the ledger - node.active.vote (vote_fork, true); + node.active.vote (vote_fork); // Block now gets processed ASSERT_EQ (nano::process_result::fork, node.process_local (fork).code); @@ -1735,9 +1735,9 @@ TEST (active_transactions, pessimistic_elections) // Make dummy election with winner. { nano::election election1 ( - node, send, [](auto const &) {}, [](auto const &, bool) {}, false, nano::election_behavior::normal); + node, send, [](auto const &) {}, [](auto const &) {}, false, nano::election_behavior::normal); nano::election election2 ( - node, open, [](auto const &) {}, [](auto const &, bool) {}, false, nano::election_behavior::normal); + node, open, [](auto const &) {}, [](auto const &) {}, false, nano::election_behavior::normal); node.active.add_expired_optimistic_election (election1); node.active.add_expired_optimistic_election (election2); } diff --git a/nano/core_test/conflicts.cpp b/nano/core_test/conflicts.cpp index 9c26fcfcb2..a7912336fb 100644 --- a/nano/core_test/conflicts.cpp +++ b/nano/core_test/conflicts.cpp @@ -40,7 +40,7 @@ TEST (conflicts, add_existing) auto election1 = node1.active.insert (send2); ASSERT_EQ (1, node1.active.size ()); auto vote1 (std::make_shared (key2.pub, key2.prv, 0, send2)); - node1.active.vote (vote1, true); + node1.active.vote (vote1); ASSERT_NE (nullptr, election1.election); ASSERT_EQ (2, election1.election->votes ().size ()); auto votes (election1.election->votes ()); diff --git a/nano/core_test/election.cpp b/nano/core_test/election.cpp index a6793ce713..39807af31b 100644 --- a/nano/core_test/election.cpp +++ b/nano/core_test/election.cpp @@ -54,7 +54,7 @@ TEST (election, quorum_minimum_flip_success) ASSERT_NE (nullptr, election.election); ASSERT_EQ (2, election.election->blocks ().size ()); auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, send2)); - ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1, true)); + ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); node1.block_processor.flush (); ASSERT_NE (nullptr, node1.block (send2->hash ())); ASSERT_TRUE (election.election->confirmed ()); @@ -98,7 +98,7 @@ TEST (election, quorum_minimum_flip_fail) ASSERT_NE (nullptr, election.election); ASSERT_EQ (2, election.election->blocks ().size ()); auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, send2)); - ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1, true)); + ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); node1.block_processor.flush (); ASSERT_NE (nullptr, node1.block (send1->hash ())); ASSERT_FALSE (election.election->confirmed ()); @@ -130,7 +130,7 @@ TEST (election, quorum_minimum_confirm_success) ASSERT_NE (nullptr, election.election); ASSERT_EQ (1, election.election->blocks ().size ()); auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, send1)); - ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1, true)); + ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); node1.block_processor.flush (); ASSERT_NE (nullptr, node1.block (send1->hash ())); ASSERT_TRUE (election.election->confirmed ()); @@ -162,7 +162,7 @@ TEST (election, quorum_minimum_confirm_fail) ASSERT_NE (nullptr, election.election); ASSERT_EQ (1, election.election->blocks ().size ()); auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, send1)); - ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1, true)); + ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); node1.block_processor.flush (); ASSERT_NE (nullptr, node1.block (send1->hash ())); ASSERT_FALSE (election.election->confirmed ()); @@ -232,7 +232,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks) ASSERT_NE (nullptr, election.election); ASSERT_EQ (1, election.election->blocks ().size ()); auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), send1)); - ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1, true)); + ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); auto vote2 (std::make_shared (key1.pub, key1.prv, nano::milliseconds_since_epoch (), send1)); auto channel = node1.network.find_channel (node2.network.endpoint ()); ASSERT_NE (channel, nullptr); @@ -243,7 +243,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks) // Modify online_m for online_reps to more than is available, this checks that voting below updates it to current online reps. node1.online_reps.online_m = node_config.online_weight_minimum.number () + 20; } - ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2, true)); + ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2)); node1.block_processor.flush (); ASSERT_NE (nullptr, node1.block (send1->hash ())); ASSERT_TRUE (election.election->confirmed ()); diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 71a6652547..483a7b020b 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -790,9 +790,9 @@ TEST (votes, add_one) auto election1 = node1.active.insert (send1); ASSERT_EQ (1, election1.election->votes ().size ()); auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, send1)); - ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1, true)); + ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); auto vote2 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 2, send1)); - ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2, true)); + ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2)); ASSERT_EQ (2, election1.election->votes ().size ()); auto votes1 (election1.election->votes ()); auto existing1 (votes1.find (nano::dev_genesis_key.pub)); @@ -818,9 +818,9 @@ TEST (votes, add_two) nano::keypair key2; auto send2 (std::make_shared (genesis.hash (), key2.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); auto vote2 (std::make_shared (key2.pub, key2.prv, 1, send2)); - ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2, true)); + ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2)); auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, send1)); - ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1, true)); + ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); ASSERT_EQ (3, election1.election->votes ().size ()); auto votes1 (election1.election->votes ()); ASSERT_NE (votes1.end (), votes1.find (nano::dev_genesis_key.pub)); @@ -855,7 +855,7 @@ TEST (votes, add_existing) ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code); auto election1 = node1.active.insert (send1); auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, send1)); - ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1, true)); + ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); // Block is already processed from vote ASSERT_TRUE (node1.active.publish (send1)); ASSERT_EQ (1, election1.election->last_votes[nano::dev_genesis_key.pub].timestamp); @@ -875,14 +875,14 @@ TEST (votes, add_existing) nano::unique_lock lock (election1.election->mutex); election1.election->last_votes[nano::dev_genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); lock.unlock (); - ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2, true)); + ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2)); ASSERT_FALSE (node1.active.publish (send2)); ASSERT_EQ (2, election1.election->last_votes[nano::dev_genesis_key.pub].timestamp); // Also resend the old vote, and see if we respect the timestamp lock.lock (); election1.election->last_votes[nano::dev_genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); lock.unlock (); - ASSERT_EQ (nano::vote_code::replay, node1.active.vote (vote1, true)); + ASSERT_EQ (nano::vote_code::replay, node1.active.vote (vote1)); ASSERT_EQ (2, election1.election->votes ()[nano::dev_genesis_key.pub].timestamp); auto votes (election1.election->votes ()); ASSERT_EQ (2, votes.size ()); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 06681b18da..66e33f2bbd 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -2459,6 +2459,58 @@ TEST (node, online_reps) ASSERT_EQ (node1.config.online_weight_minimum, node1.online_reps.trended ()); } +namespace nano +{ +TEST (node, online_reps_rep_crawler) +{ + nano::system system; + nano::node_flags flags; + flags.disable_rep_crawler = true; + auto & node1 = *system.add_node (flags); + auto vote = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector{ nano::genesis_hash }); + ASSERT_EQ (0, node1.online_reps.online ()); + // Without rep crawler + node1.vote_processor.vote_blocking (vote, std::make_shared (node1)); + ASSERT_EQ (0, node1.online_reps.online ()); + // After inserting to rep crawler + { + nano::lock_guard guard (node1.rep_crawler.probable_reps_mutex); + node1.rep_crawler.active.insert (nano::genesis_hash); + } + node1.vote_processor.vote_blocking (vote, std::make_shared (node1)); + ASSERT_EQ (nano::genesis_amount, node1.online_reps.online ()); +} +} + +TEST (node, online_reps_election) +{ + nano::system system; + nano::node_flags flags; + flags.disable_rep_crawler = true; + auto & node1 = *system.add_node (flags); + // Start election + nano::genesis genesis; + 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 (); + node1.process_active (send1); + node1.block_processor.flush (); + ASSERT_EQ (1, node1.active.size ()); + // Process vote for ongoing election + auto vote = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector{ send1->hash () }); + ASSERT_EQ (0, node1.online_reps.online ()); + node1.vote_processor.vote_blocking (vote, std::make_shared (node1)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, node1.online_reps.online ()); +} + TEST (node, block_confirm) { std::vector types{ nano::transport::transport_type::tcp, nano::transport::transport_type::udp }; @@ -3973,7 +4025,7 @@ TEST (node, rollback_vote_self) { ASSERT_EQ (1, election->votes ().size ()); // Vote with key to switch the winner - election->vote (key.pub, 0, fork->hash (), true); + election->vote (key.pub, 0, fork->hash ()); ASSERT_EQ (2, election->votes ().size ()); // The winner changed ASSERT_EQ (election->winner (), fork); diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp index 52a915ecda..8fe35965f2 100644 --- a/nano/core_test/vote_processor.cpp +++ b/nano/core_test/vote_processor.cpp @@ -209,7 +209,7 @@ TEST (vote_processor, no_broadcast_local) ASSERT_FALSE (node.wallets.reps ().have_half_rep ()); // Process a vote auto vote = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector{ send->hash () }); - ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote, true)); + ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote)); // Make sure the vote was processed auto election (node.active.election (send->qualified_root ())); ASSERT_NE (nullptr, election); @@ -242,7 +242,7 @@ TEST (vote_processor, no_broadcast_local) node.block_confirm (send2); // Process a vote auto vote2 = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector{ send2->hash () }); - ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote2, true)); + ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote2)); // Make sure the vote was processed auto election2 (node.active.election (send2->qualified_root ())); ASSERT_NE (nullptr, election2); @@ -276,7 +276,7 @@ TEST (vote_processor, no_broadcast_local) ASSERT_TRUE (node.wallets.reps ().have_half_rep ()); // Process a vote auto vote3 = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector{ open->hash () }); - ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote3, true)); + ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote3)); // Make sure the vote was processed auto election3 (node.active.election (open->qualified_root ())); ASSERT_NE (nullptr, election3); diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 053a5b6194..739f173f3a 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -827,12 +827,9 @@ nano::election_insertion_result nano::active_transactions::insert_impl (nano::un double multiplier (normalized_multiplier (*block_a)); bool prioritized = roots.size () < prioritized_cutoff || multiplier > last_prioritized_multiplier.value_or (0); result.election = nano::make_shared ( - node, block_a, confirmation_action_a, [& node = node](auto const & rep_a, bool rep_is_active_a) { - if (rep_is_active_a) - { - // Representative is defined as online if replying to live votes or rep_crawler queries - node.online_reps.observe (rep_a); - } + node, block_a, confirmation_action_a, [& node = node](auto const & rep_a) { + // Representative is defined as online if replying to live votes or rep_crawler queries + node.online_reps.observe (rep_a); }, prioritized, election_behavior_a); roots.get ().emplace (nano::active_transactions::conflict_info{ root, multiplier, result.election, epoch, previous_balance }); @@ -870,7 +867,7 @@ nano::election_insertion_result nano::active_transactions::insert (std::shared_p } // Validate a vote and apply it to the current election if one exists -nano::vote_code nano::active_transactions::vote (std::shared_ptr vote_a, bool active_in_rep_crawler_a) +nano::vote_code nano::active_transactions::vote (std::shared_ptr vote_a) { nano::vote_code result{ nano::vote_code::indeterminate }; // If all hashes were recently confirmed then it is a replay @@ -924,7 +921,7 @@ nano::vote_code nano::active_transactions::vote (std::shared_ptr vot bool processed (false); for (auto const & [election, block_hash] : process) { - auto const result_l = election->vote (vote_a->account, vote_a->timestamp, block_hash, active_in_rep_crawler_a); + auto const result_l = election->vote (vote_a->account, vote_a->timestamp, block_hash); processed = processed || result_l.processed; replay = replay || result_l.replay; } diff --git a/nano/node/active_transactions.hpp b/nano/node/active_transactions.hpp index e2858f99b3..1474ebc7c0 100644 --- a/nano/node/active_transactions.hpp +++ b/nano/node/active_transactions.hpp @@ -178,7 +178,7 @@ class active_transactions final nano::election_insertion_result insert (std::shared_ptr const &, boost::optional const & = boost::none, nano::election_behavior = nano::election_behavior::normal, std::function)> const & = nullptr); // clang-format on // Distinguishes replay votes, cannot be determined if the block is not in any election - nano::vote_code vote (std::shared_ptr, bool); + nano::vote_code vote (std::shared_ptr); // Is the root of this block in the roots container bool active (nano::block const &); bool active (nano::qualified_root const &); diff --git a/nano/node/election.cpp b/nano/node/election.cpp index c1693a4c5c..6ceb07ffbd 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -18,9 +18,9 @@ nano::election_vote_result::election_vote_result (bool replay_a, bool processed_ processed = processed_a; } -nano::election::election (nano::node & node_a, std::shared_ptr block_a, std::function)> const & confirmation_action_a, std::function const & pre_confirm_action_a, bool prioritized_a, nano::election_behavior election_behavior_a) : +nano::election::election (nano::node & node_a, std::shared_ptr block_a, std::function)> const & confirmation_action_a, std::function const & live_vote_action_a, bool prioritized_a, nano::election_behavior election_behavior_a) : confirmation_action (confirmation_action_a), -pre_confirm_action (pre_confirm_action_a), +live_vote_action (live_vote_action_a), prioritized_m (prioritized_a), behavior (election_behavior_a), node (node_a), @@ -328,7 +328,7 @@ std::shared_ptr nano::election::find (nano::block_hash const & hash return result; } -nano::election_vote_result nano::election::vote (nano::account const & rep, uint64_t timestamp_a, nano::block_hash const & block_hash_a, bool rep_is_active_a) +nano::election_vote_result nano::election::vote (nano::account const & rep, uint64_t timestamp_a, nano::block_hash const & block_hash_a) { auto replay (false); auto online_stake (node.online_reps.trended ()); @@ -373,7 +373,7 @@ nano::election_vote_result nano::election::vote (nano::account const & rep, uint { node.stats.inc (nano::stat::type::election, nano::stat::detail::vote_new); last_votes[rep] = { std::chrono::steady_clock::now (), timestamp_a, block_hash_a }; - pre_confirm_action (rep, rep_is_active_a); + live_vote_action (rep); if (!confirmed ()) { confirm_if_quorum (lock); diff --git a/nano/node/election.hpp b/nano/node/election.hpp index 25e57d9e52..806b700fe8 100644 --- a/nano/node/election.hpp +++ b/nano/node/election.hpp @@ -63,7 +63,7 @@ class election final : public std::enable_shared_from_this // 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)> confirmation_action; - std::function pre_confirm_action; + std::function live_vote_action; private: // State management enum class state_t @@ -112,9 +112,9 @@ class election final : public std::enable_shared_from_this nano::election_status status; public: // Interface - election (nano::node &, std::shared_ptr, std::function)> const &, std::function const &, bool, nano::election_behavior); + election (nano::node &, std::shared_ptr, std::function)> const &, std::function const &, bool, nano::election_behavior); std::shared_ptr find (nano::block_hash const &) const; - nano::election_vote_result vote (nano::account const &, uint64_t, nano::block_hash const &, bool); + nano::election_vote_result vote (nano::account const &, uint64_t, nano::block_hash const &); bool publish (std::shared_ptr const & block_a); size_t insert_inactive_votes_cache (nano::inactive_cache_information const &); // Confirm this block if quorum is met diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index e14bfbab79..75be89c8ef 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -150,6 +150,7 @@ class rep_crawler final friend class active_transactions_confirm_active_Test; friend class active_transactions_confirm_frontier_Test; friend class rep_crawler_local_Test; + friend class node_online_reps_rep_crawler_Test; std::deque, std::shared_ptr>> responses; }; diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp index ed86c05dcf..7cb1138892 100644 --- a/nano/node/vote_processor.cpp +++ b/nano/node/vote_processor.cpp @@ -172,7 +172,7 @@ nano::vote_code nano::vote_processor::vote_blocking (std::shared_ptr auto result (nano::vote_code::invalid); if (validated || !vote_a->validate ()) { - result = active.vote (vote_a, !rep_crawler.response (channel_a, vote_a)); + result = active.vote (vote_a); observers.vote.notify (vote_a, channel_a, result); } std::string status;