Merge pull request #364 from AntelopeIO/GH-353-finality-name

Rename instant_finality_extension to finality_extension

Author: heifner

libraries/chain/abi_serializer.cpp

@@ -1,7 +1,7 @@
 #include <eosio/chain/abi_serializer.hpp>
 #include <eosio/chain/asset.hpp>
 #include <eosio/chain/exceptions.hpp>
-#include <eosio/chain/finality/instant_finality_extension.hpp>
+#include <eosio/chain/finality/finality_extension.hpp>
 #include <fc/io/raw.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include <fc/io/varint.hpp>
@@ -634,11 +634,10 @@ namespace eosio { namespace chain {
       _variant_to_binary(type, var, ds, ctx);
    }
 
-   void impl::abi_to_variant::add_block_header_instant_finality_extension( mutable_variant_object& mvo, const header_extension_multimap& header_exts ) {
-      if (header_exts.count(instant_finality_extension::extension_id())) {
-         const auto& if_extension =
-                 std::get<instant_finality_extension>(header_exts.lower_bound(instant_finality_extension::extension_id())->second);
-         mvo("instant_finality_extension", if_extension);
+   void impl::abi_to_variant::add_block_header_finality_extension( mutable_variant_object& mvo, const header_extension_multimap& header_exts ) {
+      if (header_exts.count(finality_extension::extension_id())) {
+         const auto& f_ext = std::get<finality_extension>(header_exts.lower_bound(finality_extension::extension_id())->second);
+         mvo("finality_extension", f_ext);
       }
    }
 

libraries/chain/block_header_state.cpp

@@ -1,6 +1,6 @@
 #include <eosio/chain/block_header_state.hpp>
 #include <eosio/chain/block_header_state_utils.hpp>
-#include <eosio/chain/finality/instant_finality_extension.hpp>
+#include <eosio/chain/finality/finality_extension.hpp>
 #include <eosio/chain/finality/proposer_policy.hpp>
 #include <eosio/chain/exceptions.hpp>
 #include <limits>
@@ -174,7 +174,7 @@ void evaluate_finalizer_policies_for_promotion(const block_header_state& prev,
 
 // -------------------------------------------------------------------------------------------------
 // `finish_next` updates the next `block_header_state` according to the contents of the
-// header extensions (either new protocol_features or instant_finality_extension) applicable to this
+// header extensions (either new protocol_features or finality_extension) applicable to this
 // next block .
 //
 // These extensions either result from the execution of the previous block (in case this node
@@ -183,7 +183,7 @@ void evaluate_finalizer_policies_for_promotion(const block_header_state& prev,
 void finish_next(const block_header_state& prev,
                  block_header_state& next_header_state,
                  vector<digest_type> new_protocol_feature_activations,
-                 instant_finality_extension if_ext,
+                 finality_extension f_ext,
                  bool log) { // only log on assembled blocks, to avoid double logging
    // activated protocol features
    // ---------------------------
@@ -210,8 +210,8 @@ void finish_next(const block_header_state& prev,
    }
 
    std::optional<proposer_policy> new_proposer_policy;
-   if (if_ext.new_proposer_policy_diff) {
-      new_proposer_policy = prev.get_last_proposed_proposer_policy().apply_diff(*if_ext.new_proposer_policy_diff);
+   if (f_ext.new_proposer_policy_diff) {
+      new_proposer_policy = prev.get_last_proposed_proposer_policy().apply_diff(*f_ext.new_proposer_policy_diff);
    }
    if (new_proposer_policy) {
       // called when assembling the block
@@ -226,7 +226,7 @@ void finish_next(const block_header_state& prev,
       .timestamp = prev.timestamp(),
       .finalizer_policy_generation = prev.active_finalizer_policy->generation
    };
-   next_header_state.core = prev.core.next(parent_block, if_ext.qc_claim);
+   next_header_state.core = prev.core.next(parent_block, f_ext.qc_claim);
 
    // finalizer policy
    // ----------------
@@ -236,8 +236,8 @@ void finish_next(const block_header_state& prev,
 
    next_header_state.last_pending_finalizer_policy_digest = fc::sha256::hash(next_header_state.get_last_pending_finalizer_policy());
 
-   if (if_ext.new_finalizer_policy_diff) {
-      finalizer_policy new_finalizer_policy = prev.get_last_proposed_finalizer_policy().apply_diff(*if_ext.new_finalizer_policy_diff);
+   if (f_ext.new_finalizer_policy_diff) {
+      finalizer_policy new_finalizer_policy = prev.get_last_proposed_finalizer_policy().apply_diff(*f_ext.new_finalizer_policy_diff);
 
       // a new `finalizer_policy` was proposed in the previous block, and is present in the previous
       // block's header extensions.
@@ -296,13 +296,13 @@ block_header_state block_header_state::next(block_header_state_input& input) con
    if (input.new_proposer_policy) {
       new_proposer_policy_diff = get_last_proposed_proposer_policy().create_diff(*input.new_proposer_policy);
    }
-   instant_finality_extension new_if_ext { input.most_recent_ancestor_with_qc,
-                                           std::move(new_finalizer_policy_diff),
-                                           std::move(new_proposer_policy_diff) };
+   finality_extension new_f_ext { input.most_recent_ancestor_with_qc,
+                                  std::move(new_finalizer_policy_diff),
+                                  std::move(new_proposer_policy_diff) };
 
-   uint16_t if_ext_id = instant_finality_extension::extension_id();
-   emplace_extension(next_header_state.header.header_extensions, if_ext_id, fc::raw::pack(new_if_ext));
-   next_header_state.header_exts.emplace(if_ext_id, new_if_ext);
+   uint16_t f_ext_id = finality_extension::extension_id();
+   emplace_extension(next_header_state.header.header_extensions, f_ext_id, fc::raw::pack(new_f_ext));
+   next_header_state.header_exts.emplace(f_ext_id, new_f_ext);
 
    // add protocol_feature_activation extension
    // -----------------------------------------
@@ -314,7 +314,7 @@ block_header_state block_header_state::next(block_header_state_input& input) con
       next_header_state.header_exts.emplace(ext_id, std::move(pfa_ext));
    }
 
-   finish_next(*this, next_header_state, std::move(input.new_protocol_feature_activations), std::move(new_if_ext), true);
+   finish_next(*this, next_header_state, std::move(input.new_protocol_feature_activations), std::move(new_f_ext), true);
 
    return next_header_state;
 }
@@ -351,17 +351,17 @@ block_header_state block_header_state::next(const signed_block_header& h, valida
       validator( timestamp(), activated_protocol_features->protocol_features, new_protocol_feature_activations );
    }
 
-   // retrieve instant_finality_extension data from block header extension
+   // retrieve finality_extension data from block header extension
    // --------------------------------------------------------------------
-   EOS_ASSERT(exts.count(instant_finality_extension::extension_id()) > 0, invalid_block_header_extension,
+   EOS_ASSERT(exts.count(finality_extension::extension_id()) > 0, invalid_block_header_extension,
               "Instant Finality Extension is expected to be present in all block headers after switch to IF");
-   auto  if_entry     = exts.lower_bound(instant_finality_extension::extension_id());
-   const auto& if_ext = std::get<instant_finality_extension>(if_entry->second);
+   auto  f_entry     = exts.lower_bound(finality_extension::extension_id());
+   const auto& f_ext = std::get<finality_extension>(f_entry->second);
 
    if (h.is_proper_svnn_block()) {
       // if there is no Finality Tree Root associated with the block,
       // then this needs to validate that h.action_mroot is the empty digest
-      auto next_core_metadata = core.next_metadata(if_ext.qc_claim);
+      auto next_core_metadata = core.next_metadata(f_ext.qc_claim);
       bool no_finality_tree_associated = core.is_genesis_block_num(next_core_metadata.final_on_strong_qc_block_num);
 
       EOS_ASSERT(no_finality_tree_associated == h.action_mroot.empty(), block_validate_exception,
@@ -371,7 +371,7 @@ block_header_state block_header_state::next(const signed_block_header& h, valida
                  ("f", next_core_metadata.final_on_strong_qc_block_num));
    };
 
-   finish_next(*this, next_header_state, std::move(new_protocol_feature_activations), if_ext, false);
+   finish_next(*this, next_header_state, std::move(new_protocol_feature_activations), f_ext, false);
 
    return next_header_state;
 }

libraries/chain/block_header_state_legacy.cpp

@@ -156,11 +156,10 @@ namespace eosio::chain {
          result.producer_to_last_implied_irb[proauth.producer_name] = dpos_proposed_irreversible_blocknum;
       }
 
-      if (header_exts.count(instant_finality_extension::extension_id())) { // transition to savanna has started
-         const auto& if_extension =
-            std::get<instant_finality_extension>(header_exts.lower_bound(instant_finality_extension::extension_id())->second);
+      if (header_exts.count(finality_extension::extension_id())) { // transition to savanna has started
+         const auto& f_ext = std::get<finality_extension>(header_exts.lower_bound(finality_extension::extension_id())->second);
          // copy over qc_claim from IF Genesis Block
-         result.qc_claim = if_extension.qc_claim;
+         result.qc_claim = f_ext.qc_claim;
       }
 
       return result;
@@ -222,11 +221,11 @@ namespace eosio::chain {
                                        .is_strong_qc = false };
          finalizer_policy no_policy;
          auto new_fin_policy_diff = no_policy.create_diff(*new_finalizer_policy);
-         emplace_extension(h.header_extensions, instant_finality_extension::extension_id(),
-                           fc::raw::pack(instant_finality_extension{ initial_if_claim, std::move(new_fin_policy_diff), {} }));
+         emplace_extension(h.header_extensions, finality_extension::extension_id(),
+                           fc::raw::pack(finality_extension{ initial_if_claim, std::move(new_fin_policy_diff), {} }));
       } else if (qc_claim) {
-         emplace_extension(h.header_extensions, instant_finality_extension::extension_id(),
-                           fc::raw::pack(instant_finality_extension{ *qc_claim, {}, {} }));
+         emplace_extension(h.header_extensions, finality_extension::extension_id(),
+                           fc::raw::pack(finality_extension{ *qc_claim, {}, {} }));
       }
 
       return h;

libraries/chain/block_state.cpp

@@ -69,10 +69,10 @@ block_state_ptr block_state::create_if_genesis_block(const block_state_legacy& b
    result.header = bsp.header;
    result.activated_protocol_features = bsp.activated_protocol_features;
 
-   assert(bsp.block->contains_header_extension(instant_finality_extension::extension_id())); // required by transition mechanism
-   instant_finality_extension if_ext = bsp.block->extract_header_extension<instant_finality_extension>();
-   assert(if_ext.new_finalizer_policy_diff); // required by transition mechanism
-   result.active_finalizer_policy = std::make_shared<finalizer_policy>(finalizer_policy{}.apply_diff(std::move(*if_ext.new_finalizer_policy_diff)));
+   assert(bsp.block->contains_header_extension(finality_extension::extension_id())); // required by transition mechanism
+   finality_extension f_ext = bsp.block->extract_header_extension<finality_extension>();
+   assert(f_ext.new_finalizer_policy_diff); // required by transition mechanism
+   result.active_finalizer_policy = std::make_shared<finalizer_policy>(finalizer_policy{}.apply_diff(std::move(*f_ext.new_finalizer_policy_diff)));
 
    block_ref genesis_block_ref {
       .block_id  = bsp.id(),
@@ -299,11 +299,11 @@ void block_state::verify_qc(const valid_quorum_certificate& qc) const {
 }
 
 qc_claim_t block_state::extract_qc_claim() const {
-   auto itr = header_exts.lower_bound(instant_finality_extension::extension_id());
+   auto itr = header_exts.lower_bound(finality_extension::extension_id());
    if (itr == header_exts.end())
       return {};
-   const auto& if_ext = std::get<instant_finality_extension>(itr->second);
-   return if_ext.qc_claim;
+   const auto& f_ext = std::get<finality_extension>(itr->second);
+   return f_ext.qc_claim;
 }
 
 valid_t block_state::new_valid(const block_header_state& next_bhs, const digest_type& action_mroot, const digest_type& strong_digest) const {