IF: Update finalizer safety information and rules for how a finalizer signs

libraries/chain/CMakeLists.txt

@@ -80,6 +80,7 @@ set(CHAIN_WEBASSEMBLY_SOURCES
 )
 
 set(CHAIN_HOTSTUFF_SOURCES
+   hotstuff/finalizer.cpp
    hotstuff/instant_finality_extension.cpp
    hotstuff/hotstuff.cpp
 )

libraries/chain/block_header_state.cpp

@@ -28,7 +28,8 @@ block_header_state_core block_header_state_core::next(qc_claim_t incoming) const
       return {*this};
    }
 
-   EOS_ASSERT(incoming.last_qc_block_num > this->last_qc_block_num, block_validate_exception,
+   EOS_ASSERT(incoming.last_qc_block_num > this->last_qc_block_num &&
+              incoming.last_qc_block_timestamp > this->last_qc_block_timestamp, block_validate_exception,
               "new last_qc_block_num ${new} must be greater than old last_qc_block_num ${old}",
               ("new", incoming.last_qc_block_num)("old", this->last_qc_block_num));
 
@@ -58,7 +59,8 @@ block_header_state_core block_header_state_core::next(qc_claim_t incoming) const
    }
 
    // new last_qc_block_num is always the input last_qc_block_num.
-   result.last_qc_block_num = incoming.last_qc_block_num;
+   result.last_qc_block_num       = incoming.last_qc_block_num;
+   result.last_qc_block_timestamp = incoming.last_qc_block_timestamp;
 
    return result;
 }
@@ -165,7 +167,7 @@ block_header_state block_header_state::next(block_header_state_input& input) con
 
    // Finally update block id from header
    // -----------------------------------
-   result.id = result.header.calculate_id();
+   result.block_id = result.header.calculate_id();
 
    return result;
 }
@@ -182,7 +184,7 @@ block_header_state block_header_state::next(const signed_block_header& h, const
                                             validator_t& validator) const {
    auto producer = detail::get_scheduled_producer(active_proposer_policy->proposer_schedule.producers, h.timestamp).producer_name;
 
-   EOS_ASSERT( h.previous == id, unlinkable_block_exception, "previous mismatch" );
+   EOS_ASSERT( h.previous == block_id, unlinkable_block_exception, "previous mismatch" );
    EOS_ASSERT( h.producer == producer, wrong_producer, "wrong producer specified" );
    EOS_ASSERT( h.confirmed == 0, block_validate_exception, "invalid confirmed ${c}", ("c", h.confirmed) );
 
@@ -205,7 +207,7 @@ block_header_state block_header_state::next(const signed_block_header& h, const
    auto& if_ext   = std::get<instant_finality_extension>(if_entry->second);
 
    building_block_input bb_input{
-      .parent_id = id,
+      .parent_id = block_id,
       .timestamp = h.timestamp,
       .producer  = producer,
       .new_protocol_feature_activations = std::move(new_protocol_feature_activations)

libraries/chain/block_header_state_legacy.cpp

@@ -210,8 +210,11 @@ namespace eosio::chain {
       if (new_finalizer_policy) {
          new_finalizer_policy->generation = 1;
          // set current block_num as qc_claim.last_qc_block_num in the IF extension
+         qc_claim_t initial_if_claim { .last_qc_block_num = block_num,
+                                       .last_qc_block_timestamp = timestamp,
+                                       .is_last_qc_strong = false };
          emplace_extension(h.header_extensions, instant_finality_extension::extension_id(),
-                           fc::raw::pack(instant_finality_extension{ { block_num, false }, std::move(new_finalizer_policy), {} }));
+                           fc::raw::pack(instant_finality_extension{ initial_if_claim, std::move(new_finalizer_policy), {} }));
       }
 
       return h;
@@ -287,8 +290,8 @@ namespace eosio::chain {
 
       block_header_state_legacy result( std::move( *static_cast<detail::block_header_state_legacy_common*>(this) ) );
 
-      result.id      = h.calculate_id();
-      result.header  = h;
+      result.id       = h.calculate_id();
+      result.header   = h;
 
       result.header_exts = std::move(exts);
 

libraries/chain/block_state.cpp

@@ -1,6 +1,7 @@
 #include <eosio/chain/block_state.hpp>
 #include <eosio/chain/block_header_state_utils.hpp>
 #include <eosio/chain/block_state_legacy.hpp>
+#include <eosio/chain/hotstuff/finalizer.hpp>
 #include <eosio/chain/exceptions.hpp>
 
 #include <fc/crypto/bls_utils.hpp>
@@ -12,7 +13,7 @@ block_state::block_state(const block_header_state& prev, signed_block_ptr b, con
    : block_header_state(prev.next(*b, pfs, validator))
    , block(std::move(b))
    , strong_digest(compute_finalizer_digest())
-   , weak_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())
 {}
 
@@ -21,7 +22,7 @@ block_state::block_state(const block_header_state& bhs, deque<transaction_metada
    : block_header_state(bhs)
    , block(std::make_shared<signed_block>(signed_block_header{bhs.header})) // [greg todo] do we need signatures?
    , strong_digest(compute_finalizer_digest())
-   , weak_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
    , cached_trxs(std::move(trx_metas))
@@ -35,7 +36,7 @@ block_state::block_state(const block_header_state& bhs, deque<transaction_metada
 
 // Used for transition from dpos to instant-finality
 block_state::block_state(const block_state_legacy& bsp) {
-   block_header_state::id = bsp.id();
+   block_header_state::block_id = bsp.id();
    header = bsp.header;
    core.last_final_block_num = bsp.block_num(); // [if todo] instant transition is not acceptable
    activated_protocol_features = bsp.activated_protocol_features;
@@ -80,10 +81,9 @@ std::pair<vote_status, std::optional<uint32_t>> block_state::aggregate_vote(cons
 
    if (it != finalizers.end()) {
       auto index = std::distance(finalizers.begin(), it);
-      const digest_type& digest = vote.strong ? strong_digest : weak_digest;
+      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,
-#warning TODO change to use std::span if possible
-                                 std::vector<uint8_t>{digest.data(), digest.data() + digest.data_size()},
+                                 digest,
                                  index,
                                  vote.finalizer_key,
                                  vote.sig,
@@ -158,22 +158,21 @@ void block_state::verify_qc(const valid_quorum_certificate& qc) const {
 
    if( qc._weak_votes ) {
       pubkeys.emplace_back(aggregate_pubkeys(*qc._weak_votes));
-      digests.emplace_back(std::vector<uint8_t>{weak_digest.data(), weak_digest.data() + weak_digest.data_size()});
+      digests.emplace_back(std::vector<uint8_t>{weak_digest.begin(), weak_digest.end()});
    }
 
    // validate aggregated signature
-   EOS_ASSERT( fc::crypto::blslib::aggregate_verify( pubkeys, digests, qc._sig ),  invalid_qc_claim, "signature validation failed" );
+   EOS_ASSERT( fc::crypto::blslib::aggregate_verify( pubkeys, digests, qc._sig ),
+               invalid_qc_claim, "signature validation failed" );
 }
 
 std::optional<quorum_certificate> block_state::get_best_qc() const {
-   auto block_number = block_num();
-
    // if pending_qc does not have a valid QC, consider valid_qc only
    if( !pending_qc.is_quorum_met() ) {
       if( valid_qc ) {
-         return quorum_certificate{ block_number, *valid_qc };
+         return quorum_certificate{ block_num(), *valid_qc };
       } else {
-         return std::nullopt;;
+         return std::nullopt;
       }
    }
 
@@ -182,7 +181,7 @@ std::optional<quorum_certificate> block_state::get_best_qc() const {
 
    // if valid_qc does not have value, consider valid_qc_from_pending only
    if( !valid_qc ) {
-      return quorum_certificate{ block_number, valid_qc_from_pending };
+      return quorum_certificate{ block_num(), valid_qc_from_pending };
    }
 
    // Both valid_qc and valid_qc_from_pending have value. Compare them and select a better one.
@@ -191,6 +190,7 @@ std::optional<quorum_certificate> block_state::get_best_qc() const {
       valid_qc->is_strong() == valid_qc_from_pending.is_strong() ?
       *valid_qc : // tie broke by valid_qc
       valid_qc->is_strong() ? *valid_qc : valid_qc_from_pending; // strong beats weak
-   return quorum_certificate{ block_number, best_qc };
-}   
+   return quorum_certificate{ block_num(), best_qc };
+}
+
 } /// eosio::chain