From d3ad6a05ba37ee6d292d75b222484c536cc06339 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Wed, 27 Oct 2021 13:18:22 +0100 Subject: [PATCH 1/5] Redesigning vote_processor::flush test to not directly modify timestamp field. The only functional change is that each vote is now its own object rather than modifying an existing one. --- nano/core_test/vote_processor.cpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp index b81d53e5f..3f515589c 100644 --- a/nano/core_test/vote_processor.cpp +++ b/nano/core_test/vote_processor.cpp @@ -52,13 +52,11 @@ TEST (vote_processor, flush) { nano::system system (1); auto & node (*system.nodes[0]); - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 1, std::vector{ nano::dev::genesis->hash () })); auto channel (std::make_shared (node)); for (unsigned i = 0; i < 2000; ++i) { - auto new_vote (std::make_shared (*vote)); - node.vote_processor.vote (new_vote, channel); - ++vote->timestamp; // invalidates votes without signing again + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 1 + i, std::vector{ nano::dev::genesis->hash () }); + node.vote_processor.vote (vote, channel); } node.vote_processor.flush (); ASSERT_TRUE (node.vote_processor.empty ()); From fb8e912dfc07cb20392a1e7357c8d62d5e04a2a8 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Wed, 27 Oct 2021 14:11:22 +0100 Subject: [PATCH 2/5] Removing timestamp changing and re-signing as this is re-testing something that's already tested above, signature correctness with respect to vote contents. --- nano/core_test/vote_processor.cpp | 6 ------ 1 file changed, 6 deletions(-) diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp index 3f515589c..4767199fa 100644 --- a/nano/core_test/vote_processor.cpp +++ b/nano/core_test/vote_processor.cpp @@ -37,12 +37,6 @@ TEST (vote_processor, codes) // Invalid takes precedence ASSERT_EQ (nano::vote_code::invalid, node.vote_processor.vote_blocking (vote_invalid, channel)); - // A higher timestamp is not a replay - ++vote->timestamp; - ASSERT_EQ (nano::vote_code::invalid, node.vote_processor.vote_blocking (vote, channel)); - vote->signature = nano::sign_message (key.prv, key.pub, vote->hash ()); - ASSERT_EQ (nano::vote_code::vote, node.vote_processor.vote_blocking (vote, channel)); - // Once the election is removed (confirmed / dropped) the vote is again indeterminate node.active.erase (*nano::dev::genesis); ASSERT_EQ (nano::vote_code::indeterminate, node.vote_processor.vote_blocking (vote, channel)); From f58fbe42a114b58e9e27eb0e4b1d89b25ec5fb5c Mon Sep 17 00:00:00 2001 From: clemahieu Date: Wed, 27 Oct 2021 15:49:48 +0100 Subject: [PATCH 3/5] Encapsulating vote::timestamp field as vote::timestamp_m behind vote::timestamp (). --- nano/core_test/vote_processor.cpp | 6 +++--- nano/node/active_transactions.cpp | 6 +++--- nano/node/network.cpp | 2 +- nano/node/vote_processor.cpp | 2 +- nano/node/voting.cpp | 6 +++--- nano/secure/common.cpp | 29 +++++++++++++++++------------ nano/secure/common.hpp | 5 ++++- 7 files changed, 32 insertions(+), 24 deletions(-) diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp index 4767199fa..3efdefab9 100644 --- a/nano/core_test/vote_processor.cpp +++ b/nano/core_test/vote_processor.cpp @@ -203,7 +203,7 @@ TEST (vote_processor, no_broadcast_local) auto votes (election->votes ()); auto existing (votes.find (nano::dev::genesis_key.pub)); ASSERT_NE (votes.end (), existing); - ASSERT_EQ (vote->timestamp, existing->second.timestamp); + ASSERT_EQ (vote->timestamp (), existing->second.timestamp); // Ensure the vote, from a local representative, was not broadcast on processing - it should be flooded on generation instead ASSERT_EQ (0, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); ASSERT_EQ (1, node.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::out)); @@ -236,7 +236,7 @@ TEST (vote_processor, no_broadcast_local) auto votes2 (election2->votes ()); auto existing2 (votes2.find (nano::dev::genesis_key.pub)); ASSERT_NE (votes2.end (), existing2); - ASSERT_EQ (vote2->timestamp, existing2->second.timestamp); + ASSERT_EQ (vote2->timestamp (), existing2->second.timestamp); // Ensure the vote was broadcast ASSERT_EQ (1, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); ASSERT_EQ (2, node.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::out)); @@ -270,7 +270,7 @@ TEST (vote_processor, no_broadcast_local) auto votes3 (election3->votes ()); auto existing3 (votes3.find (nano::dev::genesis_key.pub)); ASSERT_NE (votes3.end (), existing3); - ASSERT_EQ (vote3->timestamp, existing3->second.timestamp); + ASSERT_EQ (vote3->timestamp (), existing3->second.timestamp); // Ensure the vote wass not broadcasst ASSERT_EQ (1, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); ASSERT_EQ (3, node.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::out)); diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index c4481a479..8c05ad938 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -875,7 +875,7 @@ nano::vote_code nano::active_transactions::vote (std::shared_ptr con } else if (recently_confirmed_by_hash.count (block_hash) == 0) { - add_inactive_votes_cache (lock, block_hash, vote_a->account, vote_a->timestamp); + add_inactive_votes_cache (lock, block_hash, vote_a->account, vote_a->timestamp ()); } else { @@ -892,7 +892,7 @@ nano::vote_code nano::active_transactions::vote (std::shared_ptr con } else if (recently_confirmed_by_hash.count (block->hash ()) == 0) { - add_inactive_votes_cache (lock, block->hash (), vote_a->account, vote_a->timestamp); + add_inactive_votes_cache (lock, block->hash (), vote_a->account, vote_a->timestamp ()); } else { @@ -908,7 +908,7 @@ nano::vote_code nano::active_transactions::vote (std::shared_ptr con bool processed (false); for (auto const & [election, block_hash] : process) { - auto const result_l = election->vote (vote_a->account, vote_a->timestamp, block_hash); + 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/network.cpp b/nano/node/network.cpp index aabca2a28..0b2ed5790 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -474,7 +474,7 @@ public: { if (node.config.logging.network_message_logging ()) { - node.logger.try_log (boost::str (boost::format ("Received confirm_ack message from %1% for %2% timestamp %3%") % channel->to_string () % message_a.vote->hashes_string () % std::to_string (message_a.vote->timestamp))); + node.logger.try_log (boost::str (boost::format ("Received confirm_ack message from %1% for %2% timestamp %3%") % channel->to_string () % message_a.vote->hashes_string () % std::to_string (message_a.vote->timestamp ()))); } node.stats.inc (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::in); if (!message_a.vote->account.is_zero ()) diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp index ac540b654..71efa2596 100644 --- a/nano/node/vote_processor.cpp +++ b/nano/node/vote_processor.cpp @@ -198,7 +198,7 @@ nano::vote_code nano::vote_processor::vote_blocking (std::shared_ptr } if (config.logging.vote_logging ()) { - logger.try_log (boost::str (boost::format ("Vote from: %1% timestamp: %2% block(s): %3%status: %4%") % vote_a->account.to_account () % std::to_string (vote_a->timestamp) % vote_a->hashes_string () % status)); + logger.try_log (boost::str (boost::format ("Vote from: %1% timestamp: %2% block(s): %3%status: %4%") % vote_a->account.to_account () % std::to_string (vote_a->timestamp ()) % vote_a->hashes_string () % status)); } return result; } diff --git a/nano/node/voting.cpp b/nano/node/voting.cpp index eed58a186..a1a4956f8 100644 --- a/nano/node/voting.cpp +++ b/nano/node/voting.cpp @@ -75,11 +75,11 @@ void nano::local_vote_history::add (nano::root const & root_a, nano::block_hash auto range (history_by_root.equal_range (root_a)); for (auto i (range.first); i != range.second;) { - if (i->hash != hash_a || (vote_a->account == i->vote->account && i->vote->timestamp <= vote_a->timestamp)) + if (i->hash != hash_a || (vote_a->account == i->vote->account && i->vote->timestamp () <= vote_a->timestamp ())) { i = history_by_root.erase (i); } - else if (vote_a->account == i->vote->account && i->vote->timestamp > vote_a->timestamp) + else if (vote_a->account == i->vote->account && i->vote->timestamp () > vote_a->timestamp ()) { add_vote = false; ++i; @@ -123,7 +123,7 @@ std::vector> nano::local_vote_history::votes (nano:: auto range (history.get ().equal_range (root_a)); // clang-format off nano::transform_if (range.first, range.second, std::back_inserter (result), - [&hash_a, is_final_a](auto const & entry) { return entry.hash == hash_a && (!is_final_a || entry.vote->timestamp == std::numeric_limits::max ()); }, + [&hash_a, is_final_a](auto const & entry) { return entry.hash == hash_a && (!is_final_a || entry.vote->timestamp () == std::numeric_limits::max ()); }, [](auto const & entry) { return entry.vote; }); // clang-format on return result; diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index 4c3764e8f..613ef5178 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -473,7 +473,7 @@ bool nano::vote::operator== (nano::vote const & other_a) const } } } - return timestamp == other_a.timestamp && blocks_equal && account == other_a.account && signature == other_a.signature; + return timestamp_m == other_a.timestamp_m && blocks_equal && account == other_a.account && signature == other_a.signature; } bool nano::vote::operator!= (nano::vote const & other_a) const @@ -485,8 +485,8 @@ void nano::vote::serialize_json (boost::property_tree::ptree & tree) const { tree.put ("account", account.to_account ()); tree.put ("signature", signature.number ()); - tree.put ("sequence", std::to_string (timestamp)); - tree.put ("timestamp", std::to_string (timestamp)); + tree.put ("sequence", std::to_string (timestamp ())); + tree.put ("timestamp", std::to_string (timestamp ())); boost::property_tree::ptree blocks_tree; for (auto block : blocks) { @@ -513,8 +513,13 @@ std::string nano::vote::to_json () const return stream.str (); } +uint64_t nano::vote::timestamp () const +{ + return timestamp_m; +} + nano::vote::vote (nano::vote const & other_a) : - timestamp{ other_a.timestamp }, + timestamp_m{ other_a.timestamp_m }, blocks (other_a.blocks), account (other_a.account), signature (other_a.signature) @@ -532,7 +537,7 @@ nano::vote::vote (bool & error_a, nano::stream & stream_a, nano::block_type type { nano::read (stream_a, account.bytes); nano::read (stream_a, signature.bytes); - nano::read (stream_a, timestamp); + nano::read (stream_a, timestamp_m); while (stream_a.in_avail () > 0) { @@ -565,7 +570,7 @@ 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 const & block_a) : - timestamp{ timestamp_a }, + timestamp_m{ timestamp_a }, blocks (1, block_a), account (account_a), signature (nano::sign_message (prv_a, account_a, hash ())) @@ -573,7 +578,7 @@ nano::vote::vote (nano::account const & account_a, nano::raw_key const & prv_a, } nano::vote::vote (nano::account const & account_a, nano::raw_key const & prv_a, uint64_t timestamp_a, std::vector const & blocks_a) : - timestamp{ timestamp_a }, + timestamp_m{ timestamp_a }, account (account_a) { debug_assert (!blocks_a.empty ()); @@ -614,7 +619,7 @@ nano::block_hash nano::vote::hash () const uint64_t qword; std::array bytes; }; - qword = timestamp; + qword = timestamp_m; blake2b_update (&hash, bytes.data (), sizeof (bytes)); blake2b_final (&hash, result.bytes.data (), sizeof (result.bytes)); return result; @@ -636,7 +641,7 @@ void nano::vote::serialize (nano::stream & stream_a, nano::block_type type) cons { write (stream_a, account); write (stream_a, signature); - write (stream_a, boost::endian::native_to_little (timestamp)); + write (stream_a, boost::endian::native_to_little (timestamp_m)); for (auto const & block : blocks) { if (block.which ()) @@ -662,7 +667,7 @@ void nano::vote::serialize (nano::stream & stream_a) const { write (stream_a, account); write (stream_a, signature); - write (stream_a, boost::endian::native_to_little (timestamp)); + write (stream_a, boost::endian::native_to_little (timestamp_m)); for (auto const & block : blocks) { if (block.which ()) @@ -684,8 +689,8 @@ bool nano::vote::deserialize (nano::stream & stream_a, nano::block_uniquer * uni { nano::read (stream_a, account); nano::read (stream_a, signature); - nano::read (stream_a, timestamp); - boost::endian::little_to_native_inplace (timestamp); + nano::read (stream_a, timestamp_m); + boost::endian::little_to_native_inplace (timestamp_m); nano::block_type type; diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index 8461e32c3..92a93f3c9 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -264,8 +264,11 @@ public: boost::transform_iterator begin () const; boost::transform_iterator end () const; std::string to_json () const; + uint64_t timestamp () const; +private: // Vote timestamp - uint64_t timestamp; + uint64_t timestamp_m; +public: // The blocks, or block hashes, that this vote is for std::vector, nano::block_hash>> blocks; // Account that's voting From 9f2f1b0cf8ff0723b86a7e12afe17431d81bcd6e Mon Sep 17 00:00:00 2001 From: clemahieu Date: Wed, 27 Oct 2021 23:52:52 +0100 Subject: [PATCH 4/5] Add nano::vote::timestamp_min and nano::vote::timestamp_max variables and use these constants in tests. --- nano/core_test/active_transactions.cpp | 22 +++++++++--------- nano/core_test/conflicts.cpp | 2 +- nano/core_test/election.cpp | 12 +++++----- nano/core_test/ledger.cpp | 32 +++++++++++++------------- nano/core_test/node.cpp | 10 ++++---- nano/core_test/vote_processor.cpp | 16 ++++++------- nano/node/vote_processor.cpp | 2 +- nano/node/voting.cpp | 2 +- nano/secure/common.hpp | 6 +++-- 9 files changed, 53 insertions(+), 51 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index fd0888d15..f7be08152 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -197,7 +197,7 @@ TEST (active_transactions, inactive_votes_cache) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), std::vector (1, send->hash ()))); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, std::vector (1, send->hash ()))); node.vote_processor.vote (vote, std::make_shared (node)); ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 1); node.process_active (send); @@ -252,7 +252,7 @@ TEST (active_transactions, inactive_votes_cache_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), std::vector (1, send1->hash ()))); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, std::vector (1, send1->hash ()))); node.vote_processor.vote (vote, std::make_shared (node)); auto channel1 (node.network.udp_channels.create (node.network.endpoint ())); ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 1); @@ -306,13 +306,13 @@ TEST (active_transactions, inactive_votes_cache_existing_vote) ASSERT_NE (nullptr, election); ASSERT_GT (node.weight (key.pub), node.minimum_principal_weight ()); // Insert vote - auto vote1 (std::make_shared (key.pub, key.prv, 1, std::vector (1, send->hash ()))); + auto vote1 (std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, std::vector (1, send->hash ()))); node.vote_processor.vote (vote1, std::make_shared (node)); ASSERT_TIMELY (5s, election->votes ().size () == 2); ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::vote_new)); auto last_vote1 (election->votes ()[key.pub]); ASSERT_EQ (send->hash (), last_vote1.hash); - ASSERT_EQ (1, last_vote1.timestamp); + ASSERT_EQ (nano::vote::timestamp_min * 1, last_vote1.timestamp); // Attempt to change vote with inactive_votes_cache nano::unique_lock active_lock (node.active.mutex); node.active.add_inactive_votes_cache (active_lock, send->hash (), key.pub, 0); @@ -459,7 +459,7 @@ TEST (active_transactions, inactive_votes_cache_election_start) // Only open1 & open2 blocks elections should start (send4 is missing previous block in ledger) ASSERT_TIMELY (5s, 2 == node.active.size ()); // Confirm elections with weight quorum - auto vote0 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), hashes)); // Final vote for confirmation + auto vote0 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, hashes)); // Final vote for confirmation node.vote_processor.vote (vote0, std::make_shared (node)); ASSERT_TIMELY (5s, node.active.empty ()); ASSERT_TIMELY (5s, 5 == node.ledger.cache.cemented_count); @@ -519,7 +519,7 @@ TEST (active_transactions, vote_replays) nano::blocks_confirm (node, { send1, open1 }); 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, std::numeric_limits::max (), send1)); + auto vote_send1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, send1)); 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)); @@ -527,7 +527,7 @@ TEST (active_transactions, vote_replays) ASSERT_TIMELY (3s, node.active.size () == 1); 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, std::numeric_limits::max (), open1)); + auto vote_open1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, open1)); ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_open1)); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_open1)); ASSERT_TIMELY (3s, node.active.empty ()); @@ -547,7 +547,7 @@ TEST (active_transactions, vote_replays) node.process_active (send2); nano::blocks_confirm (node, { send2 }); ASSERT_EQ (1, node.active.size ()); - auto vote1_send2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), send2)); + auto vote1_send2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, send2)); auto vote2_send2 (std::make_shared (key.pub, key.prv, 0, send2)); ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote2_send2)); ASSERT_EQ (1, node.active.size ()); @@ -690,7 +690,7 @@ TEST (active_transactions, republish_winner) node1.block_processor.flush (); auto election = node1.active.election (fork->qualified_root ()); ASSERT_NE (nullptr, election); - auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), std::vector{ fork->hash () }); + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, std::vector{ fork->hash () }); node1.vote_processor.vote (vote, std::make_shared (node1)); node1.vote_processor.flush (); node1.block_processor.flush (); @@ -798,7 +798,7 @@ TEST (active_transactions, fork_replacement_tally) .build_shared (); node1.process_active (open); // Confirmation - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), std::vector{ send->hash (), open->hash () })); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, std::vector{ send->hash (), open->hash () })); node1.vote_processor.vote (vote, std::make_shared (node1)); } node1.block_processor.flush (); @@ -981,7 +981,7 @@ TEST (active_transactions, conflicting_block_vote_existing_election) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - auto vote_fork (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), fork)); + auto vote_fork (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, fork)); ASSERT_EQ (nano::process_result::progress, node.process_local (send).code); node.scheduler.flush (); diff --git a/nano/core_test/conflicts.cpp b/nano/core_test/conflicts.cpp index 709c1b58a..5d562bc40 100644 --- a/nano/core_test/conflicts.cpp +++ b/nano/core_test/conflicts.cpp @@ -141,7 +141,7 @@ TEST (vote_uniquer, cleanup) nano::vote_uniquer uniquer (block_uniquer); nano::keypair key; auto vote1 (std::make_shared (key.pub, key.prv, 0, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); - auto vote2 (std::make_shared (key.pub, key.prv, 1, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); + auto vote2 (std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); auto vote3 (uniquer.unique (vote1)); auto vote4 (uniquer.unique (vote2)); vote2.reset (); diff --git a/nano/core_test/election.cpp b/nano/core_test/election.cpp index 397c61cda..c271c6ec3 100644 --- a/nano/core_test/election.cpp +++ b/nano/core_test/election.cpp @@ -55,7 +55,7 @@ TEST (election, quorum_minimum_flip_success) auto election = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election); ASSERT_EQ (2, election->blocks ().size ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), send2)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, send2)); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); node1.block_processor.flush (); ASSERT_NE (nullptr, node1.block (send2->hash ())); @@ -101,7 +101,7 @@ TEST (election, quorum_minimum_flip_fail) auto election = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election); ASSERT_EQ (2, election->blocks ().size ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), send2)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, send2)); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); node1.block_processor.flush (); ASSERT_NE (nullptr, node1.block (send1->hash ())); @@ -134,7 +134,7 @@ TEST (election, quorum_minimum_confirm_success) auto election = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election); ASSERT_EQ (1, election->blocks ().size ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, send1)); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); node1.block_processor.flush (); ASSERT_NE (nullptr, node1.block (send1->hash ())); @@ -167,7 +167,7 @@ TEST (election, quorum_minimum_confirm_fail) auto election = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election); ASSERT_EQ (1, election->blocks ().size ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, send1)); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); node1.block_processor.flush (); ASSERT_NE (nullptr, node1.block (send1->hash ())); @@ -238,9 +238,9 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks) auto election = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election); ASSERT_EQ (1, election->blocks ().size ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, send1)); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); - auto vote2 (std::make_shared (key1.pub, key1.prv, std::numeric_limits::max (), send1)); + auto vote2 (std::make_shared (key1.pub, key1.prv, nano::vote::timestamp_max, send1)); auto channel = node1.network.find_channel (node2.network.endpoint ()); ASSERT_NE (channel, nullptr); ASSERT_TIMELY (10s, !node1.rep_crawler.response (channel, vote2)); diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 357249df5..6d370c7b8 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -645,7 +645,7 @@ TEST (votes, check_signature) node1.scheduler.flush (); auto election1 = node1.active.election (send1->qualified_root ()); ASSERT_EQ (1, election1->votes ().size ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 1, send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, send1)); vote1->signature.bytes[0] ^= 1; ASSERT_EQ (nano::vote_code::invalid, node1.vote_processor.vote_blocking (vote1, std::make_shared (node1))); vote1->signature.bytes[0] ^= 1; @@ -666,9 +666,9 @@ TEST (votes, add_one) node1.scheduler.flush (); auto election1 = node1.active.election (send1->qualified_root ()); ASSERT_EQ (1, election1->votes ().size ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 1, send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, send1)); 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)); + auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, send1)); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2)); ASSERT_EQ (2, election1->votes ().size ()); auto votes1 (election1->votes ()); @@ -695,9 +695,9 @@ TEST (votes, add_two) auto election1 = node1.active.election (send1->qualified_root ()); nano::keypair key2; auto send2 = std::make_shared (nano::dev::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); + auto vote2 = std::make_shared (key2.pub, key2.prv, nano::vote::timestamp_min * 1, send2); 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); + auto vote1 = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, send1); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); ASSERT_EQ (3, election1->votes ().size ()); auto votes1 = election1->votes (); @@ -734,11 +734,11 @@ TEST (votes, add_existing) node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); node1.scheduler.flush (); auto election1 = node1.active.election (send1->qualified_root ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 1, send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, send1)); 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->last_votes[nano::dev::genesis_key.pub].timestamp); + ASSERT_EQ (nano::vote::timestamp_min * 1, election1->last_votes[nano::dev::genesis_key.pub].timestamp); nano::keypair key2; std::shared_ptr send2 = builder.state () .account (nano::dev::genesis_key.pub) @@ -750,20 +750,20 @@ TEST (votes, add_existing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build (); node1.work_generate_blocking (*send2); - auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 2, send2)); + auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, send2)); // Pretend we've waited the timeout nano::unique_lock lock (election1->mutex); election1->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)); ASSERT_FALSE (node1.active.publish (send2)); - ASSERT_EQ (2, election1->last_votes[nano::dev::genesis_key.pub].timestamp); + ASSERT_EQ (nano::vote::timestamp_min * 2, election1->last_votes[nano::dev::genesis_key.pub].timestamp); // Also resend the old vote, and see if we respect the timestamp lock.lock (); election1->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)); - ASSERT_EQ (2, election1->votes ()[nano::dev::genesis_key.pub].timestamp); + ASSERT_EQ (nano::vote::timestamp_min * 2, election1->votes ()[nano::dev::genesis_key.pub].timestamp); auto votes (election1->votes ()); ASSERT_EQ (2, votes.size ()); ASSERT_NE (votes.end (), votes.find (nano::dev::genesis_key.pub)); @@ -784,13 +784,13 @@ TEST (votes, add_old) node1.block_confirm (send1); node1.scheduler.flush (); auto election1 = node1.active.election (send1->qualified_root ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 2, send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, send1)); auto channel (std::make_shared (node1)); node1.vote_processor.vote_blocking (vote1, channel); nano::keypair key2; auto send2 (std::make_shared (nano::dev::genesis->hash (), key2.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send2); - auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 1, send2)); + auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, send2)); { nano::lock_guard lock (election1->mutex); election1->last_votes[nano::dev::genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); @@ -823,13 +823,13 @@ TEST (votes, add_old_different_account) ASSERT_NE (nullptr, election2); ASSERT_EQ (1, election1->votes ().size ()); ASSERT_EQ (1, election2->votes ().size ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 2, send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, send1)); auto channel (std::make_shared (node1)); auto vote_result1 (node1.vote_processor.vote_blocking (vote1, channel)); ASSERT_EQ (nano::vote_code::vote, vote_result1); ASSERT_EQ (2, election1->votes ().size ()); ASSERT_EQ (1, election2->votes ().size ()); - auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 1, send2)); + auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, send2)); auto vote_result2 (node1.vote_processor.vote_blocking (vote2, channel)); ASSERT_EQ (nano::vote_code::vote, vote_result2); ASSERT_EQ (2, election1->votes ().size ()); @@ -857,13 +857,13 @@ TEST (votes, add_cooldown) node1.block_confirm (send1); node1.scheduler.flush (); auto election1 = node1.active.election (send1->qualified_root ()); - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 1, send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, send1)); auto channel (std::make_shared (node1)); node1.vote_processor.vote_blocking (vote1, channel); nano::keypair key2; auto send2 (std::make_shared (nano::dev::genesis->hash (), key2.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send2); - auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 2, send2)); + auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, send2)); node1.vote_processor.vote_blocking (vote2, channel); ASSERT_EQ (2, election1->votes ().size ()); auto votes (election1->votes ()); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index f283a29e9..8043789ee 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -2922,7 +2922,7 @@ TEST (node, vote_republish) node1.process_active (send1); ASSERT_TIMELY (5s, node2.block (send1->hash ())); node1.process_active (send2); - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), send2)); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, send2)); ASSERT_TRUE (node1.active.active (*send1)); ASSERT_TIMELY (10s, node2.active.active (*send1)); node1.vote_processor.vote (vote, std::make_shared (node1)); @@ -3017,7 +3017,7 @@ TEST (node, vote_by_hash_republish) node1.process_active (send2); std::vector vote_blocks; vote_blocks.push_back (send2->hash ()); - auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), vote_blocks); // Final vote for confirmation + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, vote_blocks); // Final vote for confirmation ASSERT_TRUE (node1.active.active (*send1)); ASSERT_TRUE (node2.active.active (*send1)); node1.vote_processor.vote (vote, std::make_shared (node1)); @@ -3533,7 +3533,7 @@ TEST (node, confirm_back) ASSERT_EQ (3, node.active.size ()); std::vector vote_blocks; vote_blocks.push_back (send2->hash ()); - auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), vote_blocks)); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, vote_blocks)); node.vote_processor.vote_blocking (vote, std::make_shared (node)); ASSERT_TIMELY (10s, node.active.empty ()); } @@ -4083,7 +4083,7 @@ TEST (node, rollback_gap_source) ASSERT_EQ (2, election->blocks ().size ()); ASSERT_EQ (1, election->votes ().size ()); // Confirm open - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), std::vector (1, open->hash ()))); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, std::vector (1, open->hash ()))); node.vote_processor.vote (vote1, std::make_shared (node)); ASSERT_TIMELY (5s, election->votes ().size () == 2); ASSERT_TIMELY (3s, election->confirmed ()); @@ -4110,7 +4110,7 @@ TEST (node, rollback_gap_source) node.block_processor.flush (); ASSERT_EQ (2, election->blocks ().size ()); // Confirm open (again) - auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits::max (), std::vector (1, open->hash ()))); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, std::vector (1, open->hash ()))); node.vote_processor.vote (vote1, std::make_shared (node)); ASSERT_TIMELY (5s, election->votes ().size () == 2); } diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp index 3efdefab9..f3f31ad87 100644 --- a/nano/core_test/vote_processor.cpp +++ b/nano/core_test/vote_processor.cpp @@ -12,7 +12,7 @@ TEST (vote_processor, codes) nano::system system (1); auto & node (*system.nodes[0]); nano::keypair key; - auto vote (std::make_shared (key.pub, key.prv, 1, std::vector{ nano::dev::genesis->hash () })); + auto vote (std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, std::vector{ nano::dev::genesis->hash () })); auto vote_invalid = std::make_shared (*vote); vote_invalid->signature.bytes[0] ^= 1; auto channel (std::make_shared (node)); @@ -49,7 +49,7 @@ TEST (vote_processor, flush) auto channel (std::make_shared (node)); for (unsigned i = 0; i < 2000; ++i) { - auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 1 + i, std::vector{ nano::dev::genesis->hash () }); + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * (1 + i), std::vector{ nano::dev::genesis->hash () }); node.vote_processor.vote (vote, channel); } node.vote_processor.flush (); @@ -61,7 +61,7 @@ TEST (vote_processor, invalid_signature) nano::system system{ 1 }; auto & node = *system.nodes[0]; nano::keypair key; - auto vote = std::make_shared (key.pub, key.prv, 1, std::vector{ nano::dev::genesis->hash () }); + auto vote = std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, std::vector{ nano::dev::genesis->hash () }); auto vote_invalid = std::make_shared (*vote); vote_invalid->signature.bytes[0] ^= 1; auto channel = std::make_shared (node); @@ -85,7 +85,7 @@ TEST (vote_processor, no_capacity) node_flags.vote_processor_capacity = 0; auto & node (*system.add_node (node_flags)); nano::keypair key; - auto vote (std::make_shared (key.pub, key.prv, 1, std::vector{ nano::dev::genesis->hash () })); + auto vote (std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, std::vector{ nano::dev::genesis->hash () })); auto channel (std::make_shared (node)); ASSERT_TRUE (node.vote_processor.vote (vote, channel)); } @@ -97,7 +97,7 @@ TEST (vote_processor, overflow) node_flags.vote_processor_capacity = 1; auto & node (*system.add_node (node_flags)); nano::keypair key; - auto vote (std::make_shared (key.pub, key.prv, 1, std::vector{ nano::dev::genesis->hash () })); + auto vote (std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, std::vector{ nano::dev::genesis->hash () })); auto channel (std::make_shared (node)); // No way to lock the processor, but queueing votes in quick succession must result in overflow @@ -195,7 +195,7 @@ TEST (vote_processor, no_broadcast_local) ASSERT_TRUE (node.wallets.reps ().exists (nano::dev::genesis_key.pub)); 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 () }); + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::milliseconds_since_epoch () & nano::vote::timestamp_max, std::vector{ send->hash () }); ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote)); // Make sure the vote was processed auto election (node.active.election (send->qualified_root ())); @@ -228,7 +228,7 @@ TEST (vote_processor, no_broadcast_local) ASSERT_EQ (node.config.vote_minimum, node.weight (nano::dev::genesis_key.pub)); 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 () }); + auto vote2 = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::milliseconds_since_epoch () * nano::vote::timestamp_max, std::vector{ send2->hash () }); ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote2)); // Make sure the vote was processed auto election2 (node.active.election (send2->qualified_root ())); @@ -262,7 +262,7 @@ TEST (vote_processor, no_broadcast_local) ASSERT_TRUE (node.wallets.reps ().exists (nano::dev::genesis_key.pub)); 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 () }); + auto vote3 = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::milliseconds_since_epoch () * nano::vote::timestamp_max, std::vector{ open->hash () }); ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote3)); // Make sure the vote was processed auto election3 (node.active.election (open->qualified_root ())); diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp index 71efa2596..7dced04c0 100644 --- a/nano/node/vote_processor.cpp +++ b/nano/node/vote_processor.cpp @@ -198,7 +198,7 @@ nano::vote_code nano::vote_processor::vote_blocking (std::shared_ptr } if (config.logging.vote_logging ()) { - logger.try_log (boost::str (boost::format ("Vote from: %1% timestamp: %2% block(s): %3%status: %4%") % vote_a->account.to_account () % std::to_string (vote_a->timestamp ()) % vote_a->hashes_string () % status)); + logger.try_log (boost::str (boost::format ("Vote from: %1% timestamp: %2% block(s): %3% status: %4%") % vote_a->account.to_account () % std::to_string (vote_a->timestamp ()) % vote_a->hashes_string () % status)); } return result; } diff --git a/nano/node/voting.cpp b/nano/node/voting.cpp index a1a4956f8..d6abd122d 100644 --- a/nano/node/voting.cpp +++ b/nano/node/voting.cpp @@ -361,7 +361,7 @@ void nano::vote_generator::vote (std::vector const & hashes_a, debug_assert (hashes_a.size () == roots_a.size ()); std::vector> votes_l; wallets.foreach_representative ([this, &hashes_a, &votes_l] (nano::public_key const & pub_a, nano::raw_key const & prv_a) { - auto timestamp (this->is_final ? std::numeric_limits::max () : nano::milliseconds_since_epoch ()); + auto timestamp = this->is_final ? nano::vote::timestamp_max : nano::milliseconds_since_epoch (); votes_l.emplace_back (std::make_shared (pub_a, prv_a, timestamp, hashes_a)); }); for (auto const & vote_l : votes_l) diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index 92a93f3c9..dbf735a6b 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -249,8 +249,8 @@ public: vote (nano::vote const &); vote (bool &, nano::stream &, nano::block_uniquer * = nullptr); vote (bool &, nano::stream &, nano::block_type, nano::block_uniquer * = nullptr); - vote (nano::account const &, nano::raw_key const &, uint64_t, std::shared_ptr const &); - vote (nano::account const &, nano::raw_key const &, uint64_t, std::vector const &); + vote (nano::account const &, nano::raw_key const &, uint64_t timestamp, std::shared_ptr const &); + vote (nano::account const &, nano::raw_key const &, uint64_t timestamp, std::vector const &); std::string hashes_string () const; nano::block_hash hash () const; nano::block_hash full_hash () const; @@ -265,6 +265,8 @@ public: boost::transform_iterator end () const; std::string to_json () const; uint64_t timestamp () const; + static uint64_t constexpr timestamp_max = { 0xffff'ffff'ffff'ffffULL }; + static uint64_t constexpr timestamp_min = { 0x0000'0000'0000'0001ULL }; private: // Vote timestamp uint64_t timestamp_m; From 81afa059f8ed24f25a02c7df4248151c7ca36010 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Thu, 28 Oct 2021 01:01:38 +0100 Subject: [PATCH 5/5] Formatting. --- nano/secure/common.hpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index dbf735a6b..b9542bf4d 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -267,9 +267,11 @@ public: uint64_t timestamp () const; static uint64_t constexpr timestamp_max = { 0xffff'ffff'ffff'ffffULL }; static uint64_t constexpr timestamp_min = { 0x0000'0000'0000'0001ULL }; + private: // Vote timestamp uint64_t timestamp_m; + public: // The blocks, or block hashes, that this vote is for std::vector, nano::block_hash>> blocks;