IF: Update fork database fork-choice rule

libraries/chain/block_state.cpp

@@ -32,7 +32,7 @@ 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
+   , 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);
@@ -83,7 +83,7 @@ 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) {
+vote_status 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 +92,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;
    }
 }
 

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_chain_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_chain_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, mark_valid_t::yes, ignore_duplicate_t::no );
                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 );
             }
@@ -2802,6 +2800,20 @@ struct controller_impl {
                }});
 
          if( s == controller::block_status::incomplete ) {
+            fork_db.apply_if<void>([&](auto& forkdb) {
+               const auto& bsp = std::get<std::decay_t<decltype(forkdb.chain_head)>>(cb.bsp);
+
+               uint16_t if_ext_id = instant_finality_extension::extension_id();
+               assert(bsp->header_exts.count(if_ext_id) > 0); // in all instant_finality block headers
+               const auto& if_ext = std::get<instant_finality_extension>(bsp->header_exts.lower_bound(if_ext_id)->second);
+               if (if_ext.qc_claim.is_strong_qc) {
+                  auto claimed = forkdb.search_on_branch(forkdb.head()->id(), if_ext.qc_claim.block_num);
+                  if (claimed) {
+                     set_if_irreversible_block_num(claimed->core.final_on_strong_qc_block_num);
+                  }
+               }
+            });
+
             log_irreversible();
          }
 
@@ -3111,22 +3123,19 @@ 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 aggregate_vote = [&vote](auto& forkdb) -> vote_status {
+          auto bsp = forkdb.get_block(vote.proposal_id);
+          if (bsp) {
+             return bsp->aggregate_vote(vote);
+          }
+          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
-      auto aggregate_vote_legacy = [](auto&) -> std::pair<vote_status, std::optional<uint32_t>> {
-         return {vote_status::unknown_block, {}};
+      auto aggregate_vote_legacy = [](auto&) -> vote_status {
+         return vote_status::unknown_block;
       };
-      auto [status, new_lib] = fork_db.apply<std::pair<vote_status, std::optional<uint32_t>>>(aggregate_vote_legacy, aggregate_vote);
-      if (new_lib) {
-         set_if_irreversible_block_num(*new_lib);
-      }
-      return status;
+      return fork_db.apply<vote_status>(aggregate_vote_legacy, aggregate_vote);
    }
 
    void create_and_send_vote_msg(const block_state_ptr& bsp, const fork_database_if_t& fork_db) {
@@ -3422,8 +3431,9 @@ 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 );
+            if constexpr (std::is_same_v<BSP, typename std::decay_t<decltype(forkdb.chain_head)>>) {
+               forkdb.add( bsp, mark_valid_t::no, ignore_duplicate_t::no );
+            }
 
             if (is_trusted_producer(b->producer)) {
                trusted_producer_light_validation = true;
@@ -3473,7 +3483,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, mark_valid_t::no, ignore_duplicate_t::yes);
                }
 
                emit(accepted_block_header, std::tie(bsp->block, bsp->id()));
@@ -3502,6 +3512,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 +4292,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();
 }