IF: Update fork database fork-choice rule - complex

libraries/chain/block_header_state.cpp

@@ -95,7 +95,7 @@ block_header_state block_header_state::next(block_header_state_input& input) con
 
    uint16_t if_ext_id = instant_finality_extension::extension_id();
    emplace_extension(result.header.header_extensions, if_ext_id, fc::raw::pack(new_if_ext));
-   result.header_exts.emplace(if_ext_id, std::move(new_if_ext));
+   result.header_exts.emplace(if_ext_id, std::move(new_if_ext)); // TODO: does not appear to be used
 
    // add protocol_feature_activation extension
    // -----------------------------------------

libraries/chain/block_state.cpp

@@ -15,6 +15,8 @@ block_state::block_state(const block_header_state& prev, signed_block_ptr b, con
    , strong_digest(compute_finalizer_digest())
    , weak_digest(create_weak_digest(strong_digest))
    , pending_qc(prev.active_finalizer_policy->finalizers.size(), prev.active_finalizer_policy->threshold, prev.active_finalizer_policy->max_weak_sum_before_weak_final())
+   , most_recent_ancestor_with_qc(core.latest_qc_claim())
+   , updated_core(core.next_metadata(most_recent_ancestor_with_qc))
 {
    // ASSUMPTION FROM controller_impl::apply_block = all untrusted blocks will have their signatures pre-validated here
    if( !skip_validate_signee ) {
@@ -32,7 +34,9 @@ block_state::block_state(const block_header_state& bhs, deque<transaction_metada
    , strong_digest(compute_finalizer_digest())
    , weak_digest(create_weak_digest(strong_digest))
    , pending_qc(bhs.active_finalizer_policy->finalizers.size(), bhs.active_finalizer_policy->threshold, bhs.active_finalizer_policy->max_weak_sum_before_weak_final())
-   , pub_keys_recovered(true) // probably not needed
+   , most_recent_ancestor_with_qc(core.latest_qc_claim())
+   , updated_core(core.next_metadata(most_recent_ancestor_with_qc))
+   , pub_keys_recovered(true) // called by produce_block so signature recovery of trxs must have been done
    , cached_trxs(std::move(trx_metas))
 {
    block->transactions = std::move(trx_receipts);
@@ -49,6 +53,8 @@ block_state::block_state(const block_state_legacy& bsp) {
    block_header_state::block_id = bsp.id();
    header = bsp.header;
    core = finality_core::create_core_for_genesis_block(bsp.block_num()); // [if todo] instant transition is not acceptable
+   most_recent_ancestor_with_qc = core.latest_qc_claim();
+   updated_core = core.next_metadata(most_recent_ancestor_with_qc);
    activated_protocol_features = bsp.activated_protocol_features;
 
    auto if_ext_id = instant_finality_extension::extension_id();
@@ -83,7 +89,8 @@ void block_state::set_trxs_metas( deque<transaction_metadata_ptr>&& trxs_metas,
 }
 
 // Called from net threads
-std::pair<vote_status, std::optional<uint32_t>> block_state::aggregate_vote(const vote_message& vote) {
+std::tuple<vote_status, pending_quorum_certificate::state_t>
+block_state::aggregate_vote(const vote_message& vote) {
    const auto& finalizers = active_finalizer_policy->finalizers;
    auto it = std::find_if(finalizers.begin(),
                           finalizers.end(),
@@ -92,20 +99,16 @@ std::pair<vote_status, std::optional<uint32_t>> block_state::aggregate_vote(cons
    if (it != finalizers.end()) {
       auto index = std::distance(finalizers.begin(), it);
       auto digest = vote.strong ? strong_digest.to_uint8_span() : std::span<const uint8_t>(weak_digest);
-      auto [status, strong] = pending_qc.add_vote(vote.strong,
+      return pending_qc.add_vote(block_num(),
+                                 vote.strong,
                                  digest,
                                  index,
                                  vote.finalizer_key,
                                  vote.sig,
                                  finalizers[index].weight);
-
-      std::optional<uint32_t> new_lib{};
-      if (status == vote_status::success && strong)
-         new_lib = core.final_on_strong_qc_block_num;
-      return {status, new_lib};
    } else {
       wlog( "finalizer_key (${k}) in vote is not in finalizer policy", ("k", vote.finalizer_key) );
-      return {vote_status::unknown_public_key, {}};
+      return {vote_status::unknown_public_key, pending_quorum_certificate::state_t::unrestricted};
    }
 }
 

libraries/chain/controller.cpp

@@ -971,7 +971,7 @@ struct controller_impl {
 
    // --------------- access fork_db root ----------------------------------------------------------------------
    bool fork_db_has_root() const {
-      return fork_db.apply<bool>([&](const auto& forkdb) { return !!forkdb.root(); });
+      return fork_db.apply<bool>([&](const auto& forkdb) { return !!forkdb.has_root(); });
    }
 
    block_id_type fork_db_root_block_id() const {
@@ -1004,9 +1004,9 @@ struct controller_impl {
       return prev->block_num();
    }
 
-   void fork_db_reset_to_head() {
+   void fork_db_reset_root_to_head() {
       return fork_db.apply<void>([&](auto& forkdb) {
-         forkdb.reset(*forkdb.chain_head);
+         forkdb.reset_root(*forkdb.chain_head);
       });
    }
 
@@ -1300,7 +1300,7 @@ struct controller_impl {
    void replay(std::function<bool()> check_shutdown) {
       auto blog_head = blog.head();
       if( !fork_db_has_root() ) {
-         fork_db_reset_to_head();
+         fork_db_reset_root_to_head();
          if (!blog_head)
             return;
       }
@@ -1335,7 +1335,7 @@ struct controller_impl {
                ilog( "fork database head ${h}, root ${r}", ("h", pending_head->block_num())( "r", forkdb.root()->block_num() ) );
                if( pending_head->block_num() < head->block_num() || head->block_num() < forkdb.root()->block_num() ) {
                   ilog( "resetting fork database with new last irreversible block as the new root: ${id}", ("id", head->id()) );
-                  forkdb.reset( *head );
+                  forkdb.reset_root( *head );
                } else if( head->block_num() != forkdb.root()->block_num() ) {
                   auto new_root = forkdb.search_on_branch( pending_head->id(), head->block_num() );
                   EOS_ASSERT( new_root, fork_database_exception,
@@ -1357,22 +1357,22 @@ struct controller_impl {
 
          if (snapshot_head_block != 0 && !blog_head) {
             // loading from snapshot without a block log so fork_db can't be considered valid
-            forkdb.reset( *head );
+            forkdb.reset_root( *head );
          } else if( !except_ptr && !check_shutdown() && forkdb.head() ) {
             auto head_block_num = head->block_num();
-            auto branch = forkdb.fetch_branch( forkdb.head()->id() );
+            auto branch = fork_db.fetch_branch_from_head();
             int rev = 0;
             for( auto i = branch.rbegin(); i != branch.rend(); ++i ) {
                if( check_shutdown() ) break;
                if( (*i)->block_num() <= head_block_num ) continue;
                ++rev;
-               replay_push_block<BSP>( (*i)->block, controller::block_status::validated );
+               replay_push_block<BSP>( *i, controller::block_status::validated );
             }
             ilog( "${n} reversible blocks replayed", ("n",rev) );
          }
 
          if( !forkdb.head() ) {
-            forkdb.reset( *head );
+            forkdb.reset_root( *head );
          }
 
          auto end = fc::time_point::now();
@@ -1440,7 +1440,7 @@ struct controller_impl {
          initialize_blockchain_state(genesis); // sets head to genesis state
 
          if( !forkdb.head() ) {
-            forkdb.reset( *forkdb.chain_head );
+            forkdb.reset_root( *forkdb.chain_head );
          }
       };
 
@@ -2780,10 +2780,8 @@ struct controller_impl {
             const auto& bsp = std::get<std::decay_t<decltype(forkdb.chain_head)>>(cb.bsp);
 
             if( s == controller::block_status::incomplete ) {
-               forkdb.add( bsp );
-               forkdb.mark_valid( bsp );
+               forkdb.add( bsp, true, false );
                emit( accepted_block_header, std::tie(bsp->block, bsp->id()) );
-               EOS_ASSERT( bsp == forkdb.head(), fork_database_exception, "committed block did not become the new head in fork database");
             } else if (s != controller::block_status::irreversible) {
                forkdb.mark_valid( bsp );
             }
@@ -3112,10 +3110,21 @@ struct controller_impl {
    // called from net threads and controller's thread pool
    vote_status process_vote_message( const vote_message& vote ) {
       auto aggregate_vote = [&vote](auto& forkdb) -> std::pair<vote_status, std::optional<uint32_t>> {
-         auto bsp = forkdb.get_block(vote.proposal_id);
-         if (bsp)
-            return bsp->aggregate_vote(vote);
-         return {vote_status::unknown_block, {}};
+          auto bsp = forkdb.get_block(vote.proposal_id);
+          if (bsp) {
+             auto [status, state] = bsp->aggregate_vote(vote);
+             std::optional<uint32_t> new_lib{};
+             if (status == vote_status::success && pending_quorum_certificate::is_quorum_met(state)) {
+                if (state == pending_quorum_certificate::state_t::strong) {
+                   new_lib = bsp->core.final_on_strong_qc_block_num;
+                   forkdb.update_best_qc(bsp->id(), {.block_num = bsp->block_num(), .is_strong_qc = true});
+                } else {
+                   forkdb.update_best_qc(bsp->id(), {.block_num = bsp->block_num(), .is_strong_qc = false});
+                }
+             }
+             return {status, new_lib};
+          }
+          return {vote_status::unknown_block, {}};
       };
       // TODO: https://github.com/AntelopeIO/leap/issues/2057
       // TODO: Do not aggregate votes on block_state if in legacy block fork_db
@@ -3423,7 +3432,7 @@ struct controller_impl {
 
          auto do_push = [&](auto& forkdb) {
             if constexpr (std::is_same_v<BSP, typename std::decay_t<decltype(forkdb.chain_head)>>)
-               forkdb.add( bsp );
+               forkdb.add( bsp, false, false );
 
             if (is_trusted_producer(b->producer)) {
                trusted_producer_light_validation = true;
@@ -3473,7 +3482,7 @@ struct controller_impl {
                   *forkdb.chain_head, b, protocol_features.get_protocol_feature_set(), validator, skip_validate_signee);
 
                if (s != controller::block_status::irreversible) {
-                  forkdb.add(bsp, true);
+                  forkdb.add(bsp, false, true);
                }
 
                emit(accepted_block_header, std::tie(bsp->block, bsp->id()));
@@ -3502,6 +3511,21 @@ struct controller_impl {
       } FC_LOG_AND_RETHROW( )
    }
 
+   void maybe_switch_forks(const forked_callback_t& cb, const trx_meta_cache_lookup& trx_lookup) {
+      auto maybe_switch = [&](auto& forkdb) {
+         if (read_mode != db_read_mode::IRREVERSIBLE) {
+            auto fork_head = forkdb.head();
+            if (forkdb.chain_head->id() != fork_head->id()) {
+               controller::block_report br;
+               maybe_switch_forks(br, fork_head, fork_head->is_valid() ? controller::block_status::validated : controller::block_status::complete,
+                                  cb, trx_lookup);
+            }
+         }
+      };
+
+      fork_db.apply<void>(maybe_switch);
+   }
+
    template<class BSP>
    void maybe_switch_forks( controller::block_report& br, const BSP& new_head, controller::block_status s,
                             const forked_callback_t& forked_cb, const trx_meta_cache_lookup& trx_lookup )
@@ -4267,6 +4291,12 @@ void controller::commit_block() {
    my->commit_block(block_status::incomplete);
 }
 
+void controller::maybe_switch_forks(const forked_callback_t& cb, const trx_meta_cache_lookup& trx_lookup) {
+   validate_db_available_size();
+   my->maybe_switch_forks(cb, trx_lookup);
+}
+
+
 deque<transaction_metadata_ptr> controller::abort_block() {
    return my->abort_block();
 }