IF: Implement computing finality digest

libraries/chain/block_header.cpp

@@ -25,6 +25,12 @@ namespace eosio { namespace chain {
       return result;
    }
 
+   bool block_header::is_proper_svnn_block() const {
+      auto exts = validate_and_extract_header_extensions();
+      return ( exts.count(instant_finality_extension::extension_id()) > 0 &&
+               schedule_version ==  proper_svnn_schedule_version );
+   }
+
    header_extension_multimap block_header::validate_and_extract_header_extensions()const {
       using decompose_t = block_header_extension_types::decompose_t;
 

libraries/chain/block_header_state.cpp

@@ -12,7 +12,7 @@ namespace eosio::chain {
 // header validation
 
 // data for finality_digest
-struct finality_digest_data_v0_t {
+struct finality_digest_data_v1 {
    uint32_t    major_version{light_header_protocol_version_major};
    uint32_t    minor_version{light_header_protocol_version_minor};
    uint32_t    active_finalizer_policy_generation {0};
@@ -26,36 +26,39 @@ struct base_and_active_finalizer_policy_digest_data_t {
    digest_type base_digest;
 };
 
-// data for base_digest
-struct base_digest_data_t {
-   block_header                             header;
-   finality_core                            core;
-   flat_map<uint32_t, finalizer_policy_ptr> finalizer_policies;
-   proposer_policy_ptr                      active_proposer_policy;
-   flat_map<block_timestamp_type, proposer_policy_ptr>  proposer_policies;
-   protocol_feature_activation_set_ptr      activated_protocol_features;
-};
+// compute base_digest explicitly because of pointers involved.
+digest_type block_header_state::compute_base_digest() const {
+   digest_type::encoder enc;
+
+   fc::raw::pack( enc, header );
+   fc::raw::pack( enc, core );
+
+   for (const auto& fp_pair : finalizer_policies) {
+      fc::raw::pack( enc, *fp_pair.second );
+   }
+
+   fc::raw::pack( enc, *active_proposer_policy );
+
+   for (const auto& pp_pair : proposer_policies) {
+      fc::raw::pack( enc, *pp_pair.second );
+   }
+
+   fc::raw::pack( enc, *activated_protocol_features );
+
+   return enc.result();
+}
 
 digest_type block_header_state::compute_finalizer_digest() const {
    auto active_finalizer_policy_digest = fc::sha256::hash(*active_finalizer_policy);
-
-   base_digest_data_t base_digest_data {
-      .header                      = header,
-      .core                        = core,
-      .finalizer_policies          = finalizer_policies,
-      .active_proposer_policy      = active_proposer_policy,
-      .proposer_policies           = proposer_policies,
-      .activated_protocol_features = activated_protocol_features
-   };
-   auto base_digest = fc::sha256::hash(base_digest_data);
+   auto base_digest = compute_base_digest();
 
    base_and_active_finalizer_policy_digest_data_t b_afp_digest_data {
       .active_finalizer_policy_digest = active_finalizer_policy_digest,
       .base_digest                    = base_digest
    };
    auto b_afp_digest = fc::sha256::hash(b_afp_digest_data);
 
-   finality_digest_data_v0_t finality_digest_data {
+   finality_digest_data_v1 finality_digest_data {
       .active_finalizer_policy_generation = active_finalizer_policy->generation,
       .finality_tree_digest               = finality_mroot(),
       .base_and_active_finalizer_policy_digest = b_afp_digest
@@ -85,8 +88,8 @@ block_header_state block_header_state::next(block_header_state_input& input) con
       .confirmed         = 0,
       .previous          = input.parent_id,
       .transaction_mroot = input.transaction_mroot,
-      .action_mroot      = input.finality_mroot_claim ? *input.finality_mroot_claim : digest_type{},
-      .schedule_version  = header.schedule_version
+      .action_mroot      = input.finality_mroot_claim,
+      .schedule_version  = block_header::proper_svnn_schedule_version
    };
 
    // activated protocol features
@@ -107,8 +110,7 @@ block_header_state block_header_state::next(block_header_state_input& input) con
       // +1 since this is called after the block is built, this will be the active schedule for the next block
       if (it->first.slot <= input.timestamp.slot + 1) {
          result.active_proposer_policy = it->second;
-         result.header.schedule_version = header.schedule_version + 1;
-         result.active_proposer_policy->proposer_schedule.version = result.header.schedule_version;
+         result.header.schedule_version = block_header::proper_svnn_schedule_version;
          result.proposer_policies = { ++it, proposer_policies.end() };
       } else {
          result.proposer_policies = proposer_policies;
@@ -203,20 +205,35 @@ block_header_state block_header_state::next(const signed_block_header& h, valida
       .new_protocol_feature_activations = std::move(new_protocol_feature_activations)
    };
 
+   digest_type action_mroot; // digest_type default value is empty
+
+   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 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,
+         "No Finality Tree Root associated with the block test does not match with empty action_mroot test: no finality tree associated (${n}), action_mroot empty (${e}), final_on_strong_qc_block_num (${f})",
+         ("n", no_finality_tree_associated)("e", h.action_mroot.empty())("f", next_core_metadata.final_on_strong_qc_block_num));
+
+      action_mroot = h.action_mroot;
+   };
+
    block_header_state_input bhs_input{
       bb_input,
       h.transaction_mroot,
       if_ext.new_proposer_policy,
       if_ext.new_finalizer_policy,
       if_ext.qc_claim,
-      h.action_mroot // for finality_mroot_claim
+      action_mroot // for finality_mroot_claim
    };
 
    return next(bhs_input);
 }
 
 } // namespace eosio::chain
 
-FC_REFLECT( eosio::chain::finality_digest_data_v0_t, (major_version)(minor_version)(active_finalizer_policy_generation)(finality_tree_digest)(base_and_active_finalizer_policy_digest) )
+FC_REFLECT( eosio::chain::finality_digest_data_v1, (major_version)(minor_version)(active_finalizer_policy_generation)(finality_tree_digest)(base_and_active_finalizer_policy_digest) )
 FC_REFLECT( eosio::chain::base_and_active_finalizer_policy_digest_data_t, (active_finalizer_policy_digest)(base_digest) )
-FC_REFLECT( eosio::chain::base_digest_data_t, (header)(core)(finalizer_policies)(active_proposer_policy)(proposer_policies)(activated_protocol_features) )

libraries/chain/block_state.cpp

@@ -297,28 +297,6 @@ digest_type block_state::get_finality_mroot_claim(const qc_claim_t& qc_claim) co
    return get_validation_mroot(next_core_metadata.final_on_strong_qc_block_num);
 }
 
-qc_data_t block_state::get_most_ancestor_qc_data(const std::vector<block_state_ptr>& branch) const {
-   // find most recent ancestor block that has a QC by traversing the branch
-   for( auto bsp = branch.begin(); bsp != branch.end(); ++bsp ) {
-      if( auto qc = (*bsp)->get_best_qc(); qc ) {
-         EOS_ASSERT( qc->block_num <= block_header::num_from_id(id()), block_validate_exception,
-                     "most recent ancestor QC block number (${a}) cannot be greater than current block number (${p})",
-                     ("a", qc->block_num)("p", block_header::num_from_id(id())) );
-         auto qc_claim = qc->to_qc_claim();
-         if( is_needed(qc_claim) ) {
-            return qc_data_t{ *qc, qc_claim };
-         } else {
-            // no new qc info, repeat existing
-            return qc_data_t{ {},  core.latest_qc_claim() };
-         }
-      }
-   }
-
-   // This only happens when current block is the IF genesis block or starting from snapshot.
-   // There is no ancestor block which has a QC. Construct a default QC claim.
-   return qc_data_t{ {}, core.latest_qc_claim() };
-}
-
 void inject_additional_signatures( signed_block& b, const std::vector<signature_type>& additional_signatures)
 {
    if (!additional_signatures.empty()) {

libraries/chain/controller.cpp

@@ -625,6 +625,34 @@ struct building_block {
                         v);
    }
 
+   qc_data_t get_qc_data(fork_database& fork_db, const block_state& parent) {
+      // find most recent ancestor block that has a QC by traversing fork db
+      // branch from parent
+
+      return fork_db.apply_s<qc_data_t>([&](const auto& forkdb) {
+         auto branch = forkdb.fetch_branch(parent.id());
+
+         for( auto it = branch.begin(); it != branch.end(); ++it ) {
+            if( auto qc = (*it)->get_best_qc(); qc ) {
+               EOS_ASSERT( qc->block_num <= block_header::num_from_id(parent.id()), block_validate_exception,
+                           "most recent ancestor QC block number (${a}) cannot be greater than parent's block number (${p})",
+                           ("a", qc->block_num)("p", block_header::num_from_id(parent.id())) );
+               auto qc_claim = qc->to_qc_claim();
+               if( parent.is_needed(qc_claim) ) {
+                  return qc_data_t{ *qc, qc_claim };
+               } else {
+                  // no new qc info, repeat existing
+                  return qc_data_t{ {},  parent.core.latest_qc_claim() };
+               }
+            }
+         }
+
+         // This only happens when parent block is the IF genesis block or starting from snapshot.
+         // There is no ancestor block which has a QC. Construct a default QC claim.
+         return qc_data_t{ {}, parent.core.latest_qc_claim() };
+      });
+   }
+
    assembled_block assemble_block(boost::asio::io_context& ioc,
                                   const protocol_feature_set& pfs,
                                   fork_database& fork_db,
@@ -695,11 +723,7 @@ struct building_block {
                   // second stage
                   finality_mroot_claim = validating_bsp->header.action_mroot;
                } else {
-                  auto branch = fork_db.apply_s<std::vector<block_state_ptr>>([&](const auto& forkdb) {
-                     return forkdb.fetch_branch(bb.parent.id());
-                  });
-                  qc_data = bb.parent.get_most_ancestor_qc_data(branch);
-
+                  qc_data = get_qc_data(fork_db, bb.parent);;
                   finality_mroot_claim = bb.parent.get_finality_mroot_claim(qc_data.qc_claim);
                }
 

libraries/chain/include/eosio/chain/block_header.hpp

@@ -59,6 +59,9 @@ namespace eosio::chain {
       // validation_tree(core.final_on_strong_qc_block_num).
       checksum256_type                 action_mroot;
 
+      // Proper Savanna Block's schedule_version is 1LL << 31
+      static constexpr uint32_t proper_svnn_schedule_version = (1LL << 31);
+
       /**
        * LEGACY SUPPORT - After enabling the wtmsig-blocks extension this field is deprecated and must be empty
        *
@@ -81,6 +84,9 @@ namespace eosio::chain {
       static uint32_t   num_from_id(const block_id_type& id);
       uint32_t          protocol_version() const { return 0; }
 
+      // Returns true if the block is a Proper Savanna Block
+      bool is_proper_svnn_block() const;
+
       header_extension_multimap validate_and_extract_header_extensions()const;
       std::optional<block_header_extension> extract_header_extension(uint16_t extension_id)const;
    };

libraries/chain/include/eosio/chain/block_header_state.hpp

@@ -35,8 +35,7 @@ struct block_header_state_input : public building_block_input {
    std::shared_ptr<proposer_policy>  new_proposer_policy;  // Comes from building_block::new_proposer_policy
    std::optional<finalizer_policy>   new_finalizer_policy; // Comes from building_block::new_finalizer_policy
    qc_claim_t                        most_recent_ancestor_with_qc; // Comes from traversing branch from parent and calling get_best_qc()
-                                                           // assert(qc->block_num <= num_from_id(previous));
-   std::optional<digest_type>        finality_mroot_claim;
+   digest_type                       finality_mroot_claim;
 };
 
 struct block_header_state {
@@ -61,7 +60,7 @@ struct block_header_state {
 
    // ------ functions -----------------------------------------------------------------
    const block_id_type&  id()             const { return block_id; }
-   const digest_type&    finality_mroot() const { return header.action_mroot; }
+   const digest_type     finality_mroot() const { return header.is_proper_svnn_block() ? header.action_mroot : digest_type{}; }
    block_timestamp_type  timestamp()      const { return header.timestamp; }
    account_name          producer()       const { return header.producer; }
    const block_id_type&  previous()       const { return header.previous; }
@@ -76,7 +75,11 @@ struct block_header_state {
    block_header_state next(block_header_state_input& data) const;
    block_header_state next(const signed_block_header& h, validator_t& validator) const;
 
-   digest_type           compute_finalizer_digest() const;
+   digest_type compute_base_digest() const;
+   digest_type compute_finalizer_digest() const;
+
+   // Returns true if the block is a Proper Savanna Block
+   bool is_proper_svnn_block() const;
 
    // block descending from this need the provided qc in the block extension
    bool is_needed(const qc_claim_t& qc_claim) const {

libraries/chain/include/eosio/chain/block_state.hpp

@@ -107,10 +107,6 @@ struct block_state : public block_header_state {     // block_header_state provi
    // Returns finality_mroot_claim of the current block
    digest_type get_finality_mroot_claim(const qc_claim_t& qc_claim) const;
 
-   // Returns the qc_data of the most ancestor block having a QC on the branch (including
-   // the current block)
-   qc_data_t get_most_ancestor_qc_data(const std::vector<std::shared_ptr<block_state>>& branch) const;
-
    // vote_status
    vote_status aggregate_vote(const vote_message& vote); // aggregate vote into pending_qc
    void verify_qc(const valid_quorum_certificate& qc) const; // verify given qc is valid with respect block_state

unittests/producer_schedule_if_tests.cpp

@@ -46,9 +46,6 @@ BOOST_FIXTURE_TEST_CASE( verify_producer_schedule_after_instant_finality_activat
       }
 
       BOOST_TEST(scheduled_changed_to_new);
-
-      const auto current_schd_ver = control->head_block_header().schedule_version;
-      BOOST_TEST(current_schd_ver == expected_schd_ver);
    };
 
    uint32_t lib = 0;
@@ -150,13 +147,13 @@ BOOST_FIXTURE_TEST_CASE( proposer_policy_progression_test, validating_tester ) t
    produce_blocks(config::producer_repetitions);
 
    // sch1  must become active no later than 2 rounds but sch2 cannot become active yet
-   BOOST_CHECK_EQUAL( control->active_producers().version, 1u );
+      BOOST_CHECK_EQUAL( control->active_producers().version, 1u );
    BOOST_CHECK_EQUAL( true, compare_schedules( sch1, control->active_producers() ) );
 
    produce_blocks(config::producer_repetitions);
 
    // sch2 becomes active
-   BOOST_CHECK_EQUAL( control->active_producers().version, 2u );
+      BOOST_CHECK_EQUAL( control->active_producers().version, 2u );
    BOOST_CHECK_EQUAL( true, compare_schedules( sch2, control->active_producers() ) );
 } FC_LOG_AND_RETHROW()