diff --git a/libraries/chain/block_state.cpp b/libraries/chain/block_state.cpp index f278d69039..0c88b69701 100644 --- a/libraries/chain/block_state.cpp +++ b/libraries/chain/block_state.cpp @@ -15,7 +15,7 @@ block_state::block_state(const block_header_state& prev, signed_block_ptr b, con , block(std::move(b)) , strong_digest(compute_finality_digest()) , weak_digest(create_weak_digest(strong_digest)) - , open_qc(active_finalizer_policy, pending_finalizer_policy ? pending_finalizer_policy->second : finalizer_policy_ptr{}) + , in_progress_qc(active_finalizer_policy, pending_finalizer_policy ? pending_finalizer_policy->second : finalizer_policy_ptr{}) { // ASSUMPTION FROM controller_impl::apply_block = all untrusted blocks will have their signatures pre-validated here if( !skip_validate_signee ) { @@ -37,7 +37,7 @@ block_state::block_state(const block_header_state& bhs, , block(std::make_shared(signed_block_header{bhs.header})) , strong_digest(compute_finality_digest()) , weak_digest(create_weak_digest(strong_digest)) - , open_qc(active_finalizer_policy, pending_finalizer_policy ? pending_finalizer_policy->second : finalizer_policy_ptr{}) + , in_progress_qc(active_finalizer_policy, pending_finalizer_policy ? pending_finalizer_policy->second : finalizer_policy_ptr{}) , valid(valid) , pub_keys_recovered(true) // called by produce_block so signature recovery of trxs must have been done , cached_trxs(std::move(trx_metas)) @@ -93,8 +93,8 @@ block_state_ptr block_state::create_if_genesis_block(const block_state_legacy& b result.strong_digest = result.compute_finality_digest(); // all block_header_state data populated in result at this point result.weak_digest = create_weak_digest(result.strong_digest); - // open_qc will not be used in the genesis block as finalizers will not vote on it, but still create it for consistency. - result.open_qc = open_qc_t{result.active_finalizer_policy, finalizer_policy_ptr{}}; + // in_progress_qc will not be used in the genesis block as finalizers will not vote on it, but still create it for consistency. + result.in_progress_qc = in_progress_qc_t{result.active_finalizer_policy, finalizer_policy_ptr{}}; // build leaf_node and validation_tree valid_t::finality_leaf_node_t leaf_node { @@ -156,7 +156,7 @@ block_state::block_state(snapshot_detail::snapshot_block_state_v7&& sbs) } , strong_digest(compute_finality_digest()) , weak_digest(create_weak_digest(strong_digest)) - , open_qc(active_finalizer_policy, pending_finalizer_policy ? pending_finalizer_policy->second : finalizer_policy_ptr{}) // just in case we receive votes + , in_progress_qc(active_finalizer_policy, pending_finalizer_policy ? pending_finalizer_policy->second : finalizer_policy_ptr{}) // just in case we receive votes , valid(std::move(sbs.valid)) { header_exts = header.validate_and_extract_header_extensions(); @@ -177,17 +177,17 @@ void block_state::set_trxs_metas( deque&& trxs_metas, // Called from vote threads vote_result_t block_state::aggregate_vote(uint32_t connection_id, const vote_message& vote) { auto finalizer_digest = vote.strong ? strong_digest.to_uint8_span() : std::span(weak_digest); - return open_qc.aggregate_vote(connection_id, vote, block_num(), finalizer_digest); + return in_progress_qc.aggregate_vote(connection_id, vote, block_num(), finalizer_digest); } // Only used for testing vote_status_t block_state::has_voted(const bls_public_key& key) const { - return open_qc.has_voted(key); + return in_progress_qc.has_voted(key); } // Called from net threads void block_state::verify_qc(const qc_t& qc) const { - open_qc.verify_qc(qc, strong_digest, weak_digest); + in_progress_qc.verify_qc(qc, strong_digest, weak_digest); } qc_claim_t block_state::extract_qc_claim() const { diff --git a/libraries/chain/controller.cpp b/libraries/chain/controller.cpp index a3de9e23b9..77dc0d40f1 100644 --- a/libraries/chain/controller.cpp +++ b/libraries/chain/controller.cpp @@ -3718,7 +3718,7 @@ struct controller_impl { block_state_ptr bsp = fork_db_fetch_bsp_on_branch_by_num(id, qc.block_num); if (!bsp) return {}; - return bsp->open_qc.vote_metrics(qc); + return bsp->in_progress_qc.vote_metrics(qc); } @@ -3726,7 +3726,7 @@ struct controller_impl { block_state_ptr bsp = fork_db_fetch_bsp_on_branch_by_num(id, qc.block_num); if (!bsp) return {}; - return bsp->open_qc.missing_votes(qc); + return bsp->in_progress_qc.missing_votes(qc); } // thread safe @@ -3739,7 +3739,7 @@ struct controller_impl { // net plugin subscribed to this signal. it will broadcast the vote message on receiving the signal emit(voted_block, std::tuple{uint32_t{0}, vote_result_t::success, std::cref(vote)}, __FILE__, __LINE__); - // also aggregate our own vote into the open_qc for this block, 0 connection_id indicates our own vote + // also aggregate our own vote into the in_progress_qc for this block, 0 connection_id indicates our own vote process_vote_message(0, vote); }); } diff --git a/libraries/chain/finality/qc.cpp b/libraries/chain/finality/qc.cpp index fbfe320e3b..318ccebe55 100644 --- a/libraries/chain/finality/qc.cpp +++ b/libraries/chain/finality/qc.cpp @@ -96,11 +96,11 @@ void qc_sig_t::verify(const finalizer_policy_ptr& fin_policy, } -bool open_qc_sig_t::has_voted(size_t index) const { +bool in_progess_qc_sig_t::has_voted(size_t index) const { return strong_votes.has_voted(index) || weak_votes.has_voted(index); } -void open_qc_sig_t::votes_t::reflector_init() { +void in_progess_qc_sig_t::votes_t::reflector_init() { processed = std::vector(bitset.size()); for (size_t i = 0; i < bitset.size(); ++i) { if (bitset[i]) { @@ -109,23 +109,23 @@ void open_qc_sig_t::votes_t::reflector_init() { } } -bool open_qc_sig_t::votes_t::has_voted(size_t index) const { +bool in_progess_qc_sig_t::votes_t::has_voted(size_t index) const { assert(index < processed.size()); return processed[index].value.load(std::memory_order_relaxed); } -void open_qc_sig_t::votes_t::add_vote(size_t index, const bls_signature& signature) { +void in_progess_qc_sig_t::votes_t::add_vote(size_t index, const bls_signature& signature) { processed[index].value.store(true, std::memory_order_relaxed); bitset.set(index); sig.aggregate(signature); // works even if _sig is default initialized (fp2::zero()) } -open_qc_sig_t::open_qc_sig_t() +in_progess_qc_sig_t::in_progess_qc_sig_t() : _mtx(std::make_unique()) { } -open_qc_sig_t::open_qc_sig_t(size_t num_finalizers, uint64_t quorum, uint64_t max_weak_sum_before_weak_final) +in_progess_qc_sig_t::in_progess_qc_sig_t(size_t num_finalizers, uint64_t quorum, uint64_t max_weak_sum_before_weak_final) : _mtx(std::make_unique()) , quorum(quorum) , max_weak_sum_before_weak_final(max_weak_sum_before_weak_final) @@ -133,26 +133,26 @@ open_qc_sig_t::open_qc_sig_t(size_t num_finalizers, uint64_t quorum, uint64_t ma , strong_votes(num_finalizers) { } -open_qc_sig_t::open_qc_sig_t(const finalizer_policy_ptr& finalizer_policy) - : open_qc_sig_t(finalizer_policy->finalizers.size(), - finalizer_policy->threshold, - finalizer_policy->max_weak_sum_before_weak_final()) { +in_progess_qc_sig_t::in_progess_qc_sig_t(const finalizer_policy_ptr& finalizer_policy) + : in_progess_qc_sig_t(finalizer_policy->finalizers.size(), + finalizer_policy->threshold, + finalizer_policy->max_weak_sum_before_weak_final()) { } -bool open_qc_sig_t::is_quorum_met() const { +bool in_progess_qc_sig_t::is_quorum_met() const { std::lock_guard g(*_mtx); return is_quorum_met_no_lock(); } // called with held mutex -vote_result_t open_qc_sig_t::check_duplicate(size_t index) { +vote_result_t in_progess_qc_sig_t::check_duplicate(size_t index) { if (strong_votes.bitset[index] || weak_votes.bitset[index]) return vote_result_t::duplicate; return vote_result_t::success; } // called by add_vote, already protected by mutex -vote_result_t open_qc_sig_t::add_strong_vote(size_t index, const bls_signature& sig, uint64_t weight) { +vote_result_t in_progess_qc_sig_t::add_strong_vote(size_t index, const bls_signature& sig, uint64_t weight) { strong_votes.add_vote(index, sig); strong_sum += weight; @@ -180,7 +180,7 @@ vote_result_t open_qc_sig_t::add_strong_vote(size_t index, const bls_signature& } // called by add_vote, already protected by mutex -vote_result_t open_qc_sig_t::add_weak_vote(size_t index, const bls_signature& sig, uint64_t weight) { +vote_result_t in_progess_qc_sig_t::add_weak_vote(size_t index, const bls_signature& sig, uint64_t weight) { weak_votes.add_vote(index, sig); weak_sum += weight; @@ -212,7 +212,7 @@ vote_result_t open_qc_sig_t::add_weak_vote(size_t index, const bls_signature& si } // thread safe -vote_result_t open_qc_sig_t::add_vote(uint32_t connection_id, block_num_type block_num, +vote_result_t in_progess_qc_sig_t::add_vote(uint32_t connection_id, block_num_type block_num, bool strong, size_t index, const bls_signature& sig, uint64_t weight) { std::unique_lock g(*_mtx); @@ -233,7 +233,7 @@ vote_result_t open_qc_sig_t::add_vote(uint32_t connection_id, block_num_type blo } // called by get_best_qc which acquires a mutex -qc_sig_t open_qc_sig_t::extract_qc_sig_from_open() const { +qc_sig_t in_progess_qc_sig_t::extract_qc_sig_from_open() const { qc_sig_t qc_sig; if( pending_state == state_t::strong ) { @@ -250,7 +250,7 @@ qc_sig_t open_qc_sig_t::extract_qc_sig_from_open() const { return qc_sig; } -std::optional open_qc_sig_t::get_best_qc() const { +std::optional in_progess_qc_sig_t::get_best_qc() const { std::lock_guard g(*_mtx); // if this does not have a valid QC, consider received_qc_sig only if( !is_quorum_met_no_lock() ) { @@ -275,7 +275,7 @@ std::optional open_qc_sig_t::get_best_qc() const { return std::optional{qc_sig_t{ std::move(qc_sig_from_open) }}; } -bool open_qc_sig_t::set_received_qc_sig(const qc_sig_t& qc) { +bool in_progess_qc_sig_t::set_received_qc_sig(const qc_sig_t& qc) { std::lock_guard g(*_mtx); if (!received_qc_sig || (received_qc_sig->is_weak() && qc.is_strong())) { received_qc_sig = qc; @@ -284,16 +284,16 @@ bool open_qc_sig_t::set_received_qc_sig(const qc_sig_t& qc) { return false; } -bool open_qc_sig_t::received_qc_sig_is_strong() const { +bool in_progess_qc_sig_t::received_qc_sig_is_strong() const { std::lock_guard g(*_mtx); return received_qc_sig && received_qc_sig->is_strong(); } -bool open_qc_sig_t::is_quorum_met_no_lock() const { +bool in_progess_qc_sig_t::is_quorum_met_no_lock() const { return is_quorum_met(pending_state); } -std::optional open_qc_t::get_best_qc(block_num_type block_num) const { +std::optional in_progress_qc_t::get_best_qc(block_num_type block_num) const { std::optional active_best_qc = active_policy_sig.get_best_qc(); if (!active_best_qc) // active is always required return {}; @@ -309,7 +309,7 @@ std::optional open_qc_t::get_best_qc(block_num_type block_num) const { return std::optional{qc_t{block_num, std::move(*active_best_qc), {}}}; } -void open_qc_t::verify_qc(const qc_t& qc, const digest_type& strong_digest, const weak_digest_t& weak_digest) const { +void in_progress_qc_t::verify_qc(const qc_t& qc, const digest_type& strong_digest, const weak_digest_t& weak_digest) const { if (qc.pending_policy_sig) { EOS_ASSERT(pending_finalizer_policy, invalid_qc_claim, "qc ${bn} contains pending policy signature for nonexistent pending finalizer policy", ("bn", qc.block_num)); @@ -324,7 +324,7 @@ void open_qc_t::verify_qc(const qc_t& qc, const digest_type& strong_digest, cons } } -bool open_qc_t::set_received_qc(const qc_t& qc) { +bool in_progress_qc_t::set_received_qc(const qc_t& qc) { // qc should have already been verified via verify_qc, this EOS_ASSERT should never fire EOS_ASSERT(!pending_policy_sig || qc.pending_policy_sig, invalid_qc_claim, "qc ${bn} expected to have a pending policy signature", ("bn", qc.block_num)); @@ -336,14 +336,14 @@ bool open_qc_t::set_received_qc(const qc_t& qc) { return active_better || pending_better; } -bool open_qc_t::received_qc_is_strong() const { +bool in_progress_qc_t::received_qc_is_strong() const { if (!pending_policy_sig) { // consider only active return active_policy_sig.received_qc_sig_is_strong(); } return active_policy_sig.received_qc_sig_is_strong() && pending_policy_sig->received_qc_sig_is_strong(); } -vote_result_t open_qc_t::aggregate_vote(uint32_t connection_id, const vote_message& vote, +vote_result_t in_progress_qc_t::aggregate_vote(uint32_t connection_id, const vote_message& vote, block_num_type block_num, std::span finalizer_digest) { bool verified_sig = false; @@ -357,7 +357,7 @@ vote_result_t open_qc_t::aggregate_vote(uint32_t connection_id, const vote_messa return vote_result_t::success; }; - auto add_vote = [&](const finalizer_policy_ptr& finalizer_policy, open_qc_sig_t& open_qc_sig) -> vote_result_t { + auto add_vote = [&](const finalizer_policy_ptr& finalizer_policy, in_progess_qc_sig_t& open_qc_sig) -> vote_result_t { const auto& finalizers = finalizer_policy->finalizers; auto itr = std::ranges::find_if(finalizers, [&](const auto& finalizer) { return finalizer.public_key == vote.finalizer_key; }); vote_result_t s = vote_result_t::unknown_public_key; @@ -397,9 +397,9 @@ vote_result_t open_qc_t::aggregate_vote(uint32_t connection_id, const vote_messa return s; } -vote_status_t open_qc_t::has_voted(const bls_public_key& key) const { +vote_status_t in_progress_qc_t::has_voted(const bls_public_key& key) const { auto finalizer_has_voted = [](const finalizer_policy_ptr& policy, - const open_qc_sig_t& open_qc_sig, + const in_progess_qc_sig_t& open_qc_sig, const bls_public_key& key) -> vote_status_t { const auto& finalizers = policy->finalizers; auto it = std::ranges::find_if(finalizers, [&](const auto& finalizer) { return finalizer.public_key == key; }); @@ -425,11 +425,11 @@ vote_status_t open_qc_t::has_voted(const bls_public_key& key) const { return pending_status; } -bool open_qc_t::is_quorum_met() const { +bool in_progress_qc_t::is_quorum_met() const { return active_policy_sig.is_quorum_met() && (!pending_policy_sig || pending_policy_sig->is_quorum_met()); } -qc_vote_metrics_t open_qc_t::vote_metrics(const qc_t& qc) const { +qc_vote_metrics_t in_progress_qc_t::vote_metrics(const qc_t& qc) const { qc_vote_metrics_t result; auto add_votes = [&](const finalizer_policy_ptr& finalizer_policy, const auto& votes, qc_vote_metrics_t::fin_auth_set_t& results) { @@ -474,7 +474,7 @@ qc_vote_metrics_t open_qc_t::vote_metrics(const qc_t& qc) const { return result; } -qc_vote_metrics_t::fin_auth_set_t open_qc_t::missing_votes(const qc_t& qc) const { +qc_vote_metrics_t::fin_auth_set_t in_progress_qc_t::missing_votes(const qc_t& qc) const { // all asserts are verified by verify_qc() qc_vote_metrics_t::fin_auth_set_t not_voted; diff --git a/libraries/chain/include/eosio/chain/block_state.hpp b/libraries/chain/include/eosio/chain/block_state.hpp index 37602967e3..907aad2387 100644 --- a/libraries/chain/include/eosio/chain/block_state.hpp +++ b/libraries/chain/include/eosio/chain/block_state.hpp @@ -66,7 +66,7 @@ struct block_state : public block_header_state { // block_header_state provi signed_block_ptr block; digest_type strong_digest; // finalizer_digest (strong, cached so we can quickly validate votes) weak_digest_t weak_digest; // finalizer_digest (weak, cached so we can quickly validate votes) - open_qc_t open_qc; // where we accumulate votes we receive + in_progress_qc_t in_progress_qc; // where we accumulate votes we receive std::optional valid; // ------ updated for votes, used for fork_db ordering ------------------------------ @@ -110,10 +110,10 @@ struct block_state : public block_header_state { // block_header_state provi uint32_t final_on_strong_qc_block_num() const { return core.final_on_strong_qc_block_num; } - std::optional get_best_qc() const { return open_qc.get_best_qc(block_num()); } // thread safe - bool received_qc_is_strong() const { return open_qc.received_qc_is_strong(); } // thread safe + std::optional get_best_qc() const { return in_progress_qc.get_best_qc(block_num()); } // thread safe + bool received_qc_is_strong() const { return in_progress_qc.received_qc_is_strong(); } // thread safe // return true if better qc, thread safe - bool set_received_qc(const qc_t& qc) { return open_qc.set_received_qc(qc); } + bool set_received_qc(const qc_t& qc) { return in_progress_qc.set_received_qc(qc); } // extract the qc_claim from block header finality_extension qc_claim_t extract_qc_claim() const; @@ -137,7 +137,7 @@ struct block_state : public block_header_state { // block_header_state provi finality_data_t get_finality_data(); // connection_id only for logging - vote_result_t aggregate_vote(uint32_t connection_id, const vote_message& vote); // aggregate vote into open_qc + vote_result_t aggregate_vote(uint32_t connection_id, const vote_message& vote); // aggregate vote into in_progress_qc vote_status_t has_voted(const bls_public_key& key) const; void verify_qc(const qc_t& qc) const; // verify given qc_t is valid with respect block_state @@ -185,4 +185,4 @@ using block_state_pair = std::pair, blo FC_REFLECT( eosio::chain::valid_t::finality_leaf_node_t, (major_version)(minor_version)(block_num)(finality_digest)(action_mroot) ) FC_REFLECT( eosio::chain::valid_t, (validation_tree)(validation_mroots)) FC_REFLECT( eosio::chain::finality_data_t, (major_version)(minor_version)(active_finalizer_policy_generation)(final_on_strong_qc_block_num)(action_mroot)(reversible_blocks_mroot)(base_digest)(pending_finalizer_policy) ) -FC_REFLECT_DERIVED( eosio::chain::block_state, (eosio::chain::block_header_state), (block)(strong_digest)(weak_digest)(open_qc)(valid)(validated) ) +FC_REFLECT_DERIVED( eosio::chain::block_state, (eosio::chain::block_header_state), (block)(strong_digest)(weak_digest)(in_progress_qc)(valid)(validated) ) diff --git a/libraries/chain/include/eosio/chain/finality/qc.hpp b/libraries/chain/include/eosio/chain/finality/qc.hpp index cefd3aaba7..5b7aa60eff 100644 --- a/libraries/chain/include/eosio/chain/finality/qc.hpp +++ b/libraries/chain/include/eosio/chain/finality/qc.hpp @@ -90,9 +90,9 @@ namespace eosio::chain { /** * All public methods are thread-safe. * Used for incorporating votes into a qc signature. - * "open" in that it allows new votes to be added at any time. + * "in progress" in that it allows new votes to be added at any time. */ - class open_qc_sig_t { + class in_progess_qc_sig_t { public: enum class state_t { unrestricted, // No quorum reached yet, still possible to achieve any state. @@ -107,7 +107,7 @@ namespace eosio::chain { friend struct fc::reflector; friend struct fc::reflector_init_visitor; friend struct fc::has_reflector_init; - friend class open_qc_sig_t; + friend class in_progess_qc_sig_t; struct bit_processed { alignas(hardware_destructive_interference_size) std::atomic value; @@ -137,9 +137,9 @@ namespace eosio::chain { } }; - open_qc_sig_t(); - open_qc_sig_t(size_t num_finalizers, uint64_t quorum, uint64_t max_weak_sum_before_weak_final); - explicit open_qc_sig_t(const finalizer_policy_ptr& finalizer_policy); + in_progess_qc_sig_t(); + in_progess_qc_sig_t(size_t num_finalizers, uint64_t quorum, uint64_t max_weak_sum_before_weak_final); + explicit in_progess_qc_sig_t(const finalizer_policy_ptr& finalizer_policy); bool is_quorum_met() const; static bool is_quorum_met(state_t s) { @@ -170,7 +170,7 @@ namespace eosio::chain { bool set_received_qc_sig(const qc_sig_t& qc); bool received_qc_sig_is_strong() const; private: - friend struct fc::reflector; + friend struct fc::reflector; friend class qc_chain; std::unique_ptr _mtx; std::optional received_qc_sig; // best qc_t received from the network inside block extension @@ -210,19 +210,19 @@ namespace eosio::chain { /** * All public methods are thread-safe, pending_policy_sig optional set at construction time. */ - class open_qc_t { + class in_progress_qc_t { public: - open_qc_t(const finalizer_policy_ptr& active_finalizer_policy, - const finalizer_policy_ptr& pending_finalizer_policy) + in_progress_qc_t(const finalizer_policy_ptr& active_finalizer_policy, + const finalizer_policy_ptr& pending_finalizer_policy) : active_finalizer_policy(active_finalizer_policy) , pending_finalizer_policy(pending_finalizer_policy) , active_policy_sig{active_finalizer_policy} , pending_policy_sig{!pending_finalizer_policy - ? std::optional{} - : std::optional{pending_finalizer_policy}} + ? std::optional{} + : std::optional{pending_finalizer_policy}} {} - open_qc_t() = default; + in_progress_qc_t() = default; std::optional get_best_qc(block_num_type block_num) const; // verify qc against active and pending policy @@ -239,11 +239,11 @@ namespace eosio::chain { bool is_quorum_met() const; private: - friend struct fc::reflector; - finalizer_policy_ptr active_finalizer_policy; // not modified after construction - finalizer_policy_ptr pending_finalizer_policy; // not modified after construction - open_qc_sig_t active_policy_sig; - std::optional pending_policy_sig; + friend struct fc::reflector; + finalizer_policy_ptr active_finalizer_policy; // not modified after construction + finalizer_policy_ptr pending_finalizer_policy; // not modified after construction + in_progess_qc_sig_t active_policy_sig; + std::optional pending_policy_sig; }; } //eosio::chain @@ -251,8 +251,8 @@ namespace eosio::chain { FC_REFLECT_ENUM(eosio::chain::vote_result_t, (success)(duplicate)(unknown_public_key)(invalid_signature)(unknown_block)(max_exceeded)) FC_REFLECT(eosio::chain::qc_sig_t, (strong_votes)(weak_votes)(sig)); -FC_REFLECT(eosio::chain::open_qc_sig_t, (received_qc_sig)(quorum)(max_weak_sum_before_weak_final)(pending_state)(strong_sum)(weak_sum)(weak_votes)(strong_votes)); -FC_REFLECT(eosio::chain::open_qc_t, (active_finalizer_policy)(pending_finalizer_policy)(active_policy_sig)(pending_policy_sig)); -FC_REFLECT_ENUM(eosio::chain::open_qc_sig_t::state_t, (unrestricted)(restricted)(weak_achieved)(weak_final)(strong)); -FC_REFLECT(eosio::chain::open_qc_sig_t::votes_t, (bitset)(sig)); +FC_REFLECT(eosio::chain::in_progess_qc_sig_t, (received_qc_sig)(quorum)(max_weak_sum_before_weak_final)(pending_state)(strong_sum)(weak_sum)(weak_votes)(strong_votes)); +FC_REFLECT(eosio::chain::in_progress_qc_t, (active_finalizer_policy)(pending_finalizer_policy)(active_policy_sig)(pending_policy_sig)); +FC_REFLECT_ENUM(eosio::chain::in_progess_qc_sig_t::state_t, (unrestricted)(restricted)(weak_achieved)(weak_final)(strong)); +FC_REFLECT(eosio::chain::in_progess_qc_sig_t::votes_t, (bitset)(sig)); FC_REFLECT(eosio::chain::qc_t, (block_num)(active_policy_sig)(pending_policy_sig)); diff --git a/unittests/block_state_tests.cpp b/unittests/block_state_tests.cpp index 7101a19289..0a573dac96 100644 --- a/unittests/block_state_tests.cpp +++ b/unittests/block_state_tests.cpp @@ -55,7 +55,7 @@ BOOST_AUTO_TEST_CASE(aggregate_vote_test) try { bsp->active_finalizer_policy = std::make_shared( 10, 15, active_finalizers ); bsp->strong_digest = strong_digest; bsp->weak_digest = weak_digest; - bsp->open_qc = open_qc_t{ bsp->active_finalizer_policy, {} }; + bsp->in_progress_qc = in_progress_qc_t{ bsp->active_finalizer_policy, {} }; for (size_t i = 0; i < num_finalizers; ++i) { bool strong = (i % 2 == 0); // alternate strong and weak @@ -71,7 +71,7 @@ BOOST_AUTO_TEST_CASE(aggregate_vote_test) try { bsp->pending_finalizer_policy = { bsp->block_num(), std::make_shared( 10, 15, pending_finalizers ) }; bsp->strong_digest = strong_digest; bsp->weak_digest = weak_digest; - bsp->open_qc = open_qc_t{ bsp->active_finalizer_policy, bsp->pending_finalizer_policy->second }; + bsp->in_progress_qc = in_progress_qc_t{ bsp->active_finalizer_policy, bsp->pending_finalizer_policy->second }; for (size_t i = 0; i < num_finalizers; ++i) { bool strong = (i % 2 == 0); // alternate strong and weak @@ -94,7 +94,7 @@ BOOST_AUTO_TEST_CASE(aggregate_vote_test) try { block_state_ptr bsp = std::make_shared(); bsp->active_finalizer_policy = std::make_shared( 10, 15, active_finalizers ); bsp->strong_digest = strong_digest; - bsp->open_qc = open_qc_t{ bsp->active_finalizer_policy, {} }; + bsp->in_progress_qc = in_progress_qc_t{ bsp->active_finalizer_policy, {} }; vote_message vote {block_id, true, active_public_keys[0], active_private_keys[1].sign(strong_digest.to_uint8_span()) }; BOOST_REQUIRE(bsp->aggregate_vote(0, vote) != vote_result_t::success); @@ -104,7 +104,7 @@ BOOST_AUTO_TEST_CASE(aggregate_vote_test) try { block_state_ptr bsp = std::make_shared(); bsp->active_finalizer_policy = std::make_shared( 10, 15, active_finalizers ); bsp->strong_digest = strong_digest; - bsp->open_qc = open_qc_t{ bsp->active_finalizer_policy, {} }; + bsp->in_progress_qc = in_progress_qc_t{ bsp->active_finalizer_policy, {} }; vote_message vote {block_id, true, active_public_keys[0], active_private_keys[0].sign(strong_digest.to_uint8_span()) }; BOOST_REQUIRE(bsp->aggregate_vote(0, vote) == vote_result_t::success); @@ -115,7 +115,7 @@ BOOST_AUTO_TEST_CASE(aggregate_vote_test) try { block_state_ptr bsp = std::make_shared(); bsp->active_finalizer_policy = std::make_shared( 10, 15, active_finalizers ); bsp->strong_digest = strong_digest; - bsp->open_qc = open_qc_t{ bsp->active_finalizer_policy, {} }; + bsp->in_progress_qc = in_progress_qc_t{ bsp->active_finalizer_policy, {} }; bls_private_key new_private_key{ "PVT_BLS_Wfs3KzfTI2P5F85PnoHXLnmYgSbp-XpebIdS6BUCHXOKmKXK" }; bls_public_key new_public_key{ new_private_key.get_public_key() }; @@ -129,7 +129,7 @@ BOOST_AUTO_TEST_CASE(aggregate_vote_test) try { bsp->active_finalizer_policy = std::make_shared( 10, 15, active_finalizers ); bsp->pending_finalizer_policy = { bsp->block_num(), std::make_shared( 10, 15, pending_finalizers ) }; bsp->strong_digest = strong_digest; - bsp->open_qc = open_qc_t{ bsp->active_finalizer_policy, bsp->pending_finalizer_policy->second }; + bsp->in_progress_qc = in_progress_qc_t{ bsp->active_finalizer_policy, bsp->pending_finalizer_policy->second }; bls_private_key new_private_key{ "PVT_BLS_Wfs3KzfTI2P5F85PnoHXLnmYgSbp-XpebIdS6BUCHXOKmKXK" }; bls_public_key new_public_key{ new_private_key.get_public_key() }; @@ -187,7 +187,7 @@ void do_quorum_test(const std::vector& weights, } bsp->strong_digest = strong_digest; bsp->weak_digest = weak_digest; - bsp->open_qc = open_qc_t{ bsp->active_finalizer_policy, bsp->pending_finalizer_policy ? bsp->pending_finalizer_policy->second : finalizer_policy_ptr{} }; + bsp->in_progress_qc = in_progress_qc_t{ bsp->active_finalizer_policy, bsp->pending_finalizer_policy ? bsp->pending_finalizer_policy->second : finalizer_policy_ptr{} }; for (size_t i = 0; i < num_finalizers; ++i) { if( to_vote.at(i) ) { @@ -207,7 +207,7 @@ void do_quorum_test(const std::vector& weights, } } - BOOST_REQUIRE_EQUAL(bsp->open_qc.is_quorum_met(), expected_quorum); + BOOST_REQUIRE_EQUAL(bsp->in_progress_qc.is_quorum_met(), expected_quorum); } BOOST_AUTO_TEST_CASE(quorum_test) try { @@ -334,7 +334,7 @@ BOOST_AUTO_TEST_CASE(verify_qc_test) try { constexpr uint32_t generation = 1; constexpr uint64_t threshold = 4; // 2/3 of total weights of 6 bsp->active_finalizer_policy = std::make_shared( generation, threshold, active_finalizers ); - bsp->open_qc = open_qc_t{ bsp->active_finalizer_policy, {} }; + bsp->in_progress_qc = in_progress_qc_t{ bsp->active_finalizer_policy, {} }; bsp->strong_digest = strong_digest; bsp->weak_digest = weak_digest; @@ -596,7 +596,7 @@ BOOST_AUTO_TEST_CASE(verify_qc_test_with_pending) try { constexpr uint64_t threshold = 4; // 2/3 of total weights of 6 bsp->active_finalizer_policy = std::make_shared( generation, threshold, active_finalizers ); bsp->pending_finalizer_policy = { bsp->block_num(), std::make_shared( generation, threshold, pending_finalizers ) }; - bsp->open_qc = open_qc_t{ bsp->active_finalizer_policy, bsp->pending_finalizer_policy->second }; + bsp->in_progress_qc = in_progress_qc_t{ bsp->active_finalizer_policy, bsp->pending_finalizer_policy->second }; bsp->strong_digest = strong_digest; bsp->weak_digest = weak_digest; diff --git a/unittests/finality_misc_tests.cpp b/unittests/finality_misc_tests.cpp index 71573ceb12..cdfc2720b0 100644 --- a/unittests/finality_misc_tests.cpp +++ b/unittests/finality_misc_tests.cpp @@ -9,10 +9,10 @@ #include // ----------------------------------------------------------------------------- -// Allow boost to print `open_qc_sig_t::state_t` +// Allow boost to print `in_progess_qc_sig_t::state_t` // ----------------------------------------------------------------------------- namespace std { - using state_t = eosio::chain::open_qc_sig_t::state_t; + using state_t = eosio::chain::in_progess_qc_sig_t::state_t; std::ostream& operator<<(std::ostream& os, state_t s) { switch(s) { @@ -31,7 +31,7 @@ BOOST_AUTO_TEST_SUITE(finality_misc_tests) BOOST_AUTO_TEST_CASE(qc_state_transitions) try { using namespace eosio::chain; using namespace fc::crypto::blslib; - using state_t = open_qc_sig_t::state_t; + using state_t = in_progess_qc_sig_t::state_t; digest_type d(fc::sha256("0000000000000000000000000000001")); std::vector digest(d.data(), d.data() + d.data_size()); @@ -50,11 +50,11 @@ BOOST_AUTO_TEST_CASE(qc_state_transitions) try { for (const auto& k : sk) pubkey.push_back(k.get_public_key()); - auto weak_vote = [&](open_qc_sig_t& qc, const std::vector& digest_to_sign, size_t index, uint64_t weight) { + auto weak_vote = [&](in_progess_qc_sig_t& qc, const std::vector& digest_to_sign, size_t index, uint64_t weight) { return qc.add_vote(0, 0, false, index, sk[index].sign(digest_to_sign), weight); }; - auto strong_vote = [&](open_qc_sig_t& qc, const std::vector& digest_to_sign, size_t index, uint64_t weight) { + auto strong_vote = [&](in_progess_qc_sig_t& qc, const std::vector& digest_to_sign, size_t index, uint64_t weight) { return qc.add_vote(0, 0, true, index, sk[index].sign(digest_to_sign), weight); }; @@ -63,7 +63,7 @@ BOOST_AUTO_TEST_CASE(qc_state_transitions) try { { constexpr uint64_t quorum = 1; constexpr uint64_t max_weak_sum_before_weak_final = 1; - open_qc_sig_t qc(2, quorum, max_weak_sum_before_weak_final); // 2 finalizers + in_progess_qc_sig_t qc(2, quorum, max_weak_sum_before_weak_final); // 2 finalizers BOOST_CHECK_EQUAL(qc.state(), state_t::unrestricted); // add one weak vote @@ -88,7 +88,7 @@ BOOST_AUTO_TEST_CASE(qc_state_transitions) try { { constexpr uint64_t quorum = 1; constexpr uint64_t max_weak_sum_before_weak_final = 1; - open_qc_sig_t qc(2, quorum, max_weak_sum_before_weak_final); // 2 finalizers + in_progess_qc_sig_t qc(2, quorum, max_weak_sum_before_weak_final); // 2 finalizers BOOST_CHECK_EQUAL(qc.state(), state_t::unrestricted); // add a weak vote @@ -107,7 +107,7 @@ BOOST_AUTO_TEST_CASE(qc_state_transitions) try { { constexpr uint64_t quorum = 1; constexpr uint64_t max_weak_sum_before_weak_final = 1; - open_qc_sig_t qc(2, quorum, max_weak_sum_before_weak_final); // 2 finalizers, weight_sum_minus_quorum = 1 + in_progess_qc_sig_t qc(2, quorum, max_weak_sum_before_weak_final); // 2 finalizers, weight_sum_minus_quorum = 1 BOOST_CHECK_EQUAL(qc.state(), state_t::unrestricted); // add a strong vote @@ -126,7 +126,7 @@ BOOST_AUTO_TEST_CASE(qc_state_transitions) try { { constexpr uint64_t quorum = 2; constexpr uint64_t max_weak_sum_before_weak_final = 1; - open_qc_sig_t qc(3, quorum, max_weak_sum_before_weak_final); // 3 finalizers + in_progess_qc_sig_t qc(3, quorum, max_weak_sum_before_weak_final); // 3 finalizers // add a weak vote // --------------- @@ -141,7 +141,7 @@ BOOST_AUTO_TEST_CASE(qc_state_transitions) try { BOOST_CHECK(qc.is_quorum_met()); { - open_qc_sig_t qc2(std::move(qc)); + in_progess_qc_sig_t qc2(std::move(qc)); // add a weak vote // --------------- @@ -154,7 +154,7 @@ BOOST_AUTO_TEST_CASE(qc_state_transitions) try { { constexpr uint64_t quorum = 2; constexpr uint64_t max_weak_sum_before_weak_final = 1; - open_qc_sig_t qc(3, quorum, max_weak_sum_before_weak_final); // 3 finalizers, quorum = 2 + in_progess_qc_sig_t qc(3, quorum, max_weak_sum_before_weak_final); // 3 finalizers, quorum = 2 // add a weak vote // --------------- @@ -169,7 +169,7 @@ BOOST_AUTO_TEST_CASE(qc_state_transitions) try { BOOST_CHECK(qc.is_quorum_met()); { - open_qc_sig_t qc2(std::move(qc)); + in_progess_qc_sig_t qc2(std::move(qc)); // add a strong vote // ----------------- @@ -182,7 +182,7 @@ BOOST_AUTO_TEST_CASE(qc_state_transitions) try { { constexpr uint64_t quorum = 2; constexpr uint64_t max_weak_sum_before_weak_final = 1; - open_qc_sig_t qc(3, quorum, max_weak_sum_before_weak_final); // 3 finalizers, quorum = 2 + in_progess_qc_sig_t qc(3, quorum, max_weak_sum_before_weak_final); // 3 finalizers, quorum = 2 // add a weak vote // --------------- @@ -197,7 +197,7 @@ BOOST_AUTO_TEST_CASE(qc_state_transitions) try { BOOST_CHECK(qc.is_quorum_met()); { - open_qc_sig_t qc2(std::move(qc)); + in_progess_qc_sig_t qc2(std::move(qc)); // add a weak vote // --------------- @@ -210,7 +210,7 @@ BOOST_AUTO_TEST_CASE(qc_state_transitions) try { { constexpr uint64_t quorum = 2; constexpr uint64_t max_weak_sum_before_weak_final = 1; - open_qc_sig_t qc(3, quorum, max_weak_sum_before_weak_final); // 3 finalizers, quorum = 2 + in_progess_qc_sig_t qc(3, quorum, max_weak_sum_before_weak_final); // 3 finalizers, quorum = 2 // add a weak vote // --------------- @@ -225,7 +225,7 @@ BOOST_AUTO_TEST_CASE(qc_state_transitions) try { BOOST_CHECK(qc.is_quorum_met()); { - open_qc_sig_t qc2(std::move(qc)); + in_progess_qc_sig_t qc2(std::move(qc)); // add a strong vote // -----------------