Internal wiring of finalizers in qc chain

libraries/CMakeLists.txt

@@ -22,6 +22,7 @@ add_subdirectory( testing )
 add_subdirectory( version )
 add_subdirectory( state_history )
 add_subdirectory( cli11 )
+add_subdirectory( hotstuff )
 
 set(USE_EXISTING_SOFTFLOAT ON CACHE BOOL "use pre-exisiting softfloat lib")
 set(ENABLE_TOOLS OFF CACHE BOOL "Build tools")

libraries/chain/CMakeLists.txt

@@ -122,6 +122,7 @@ add_library( eosio_chain
              ${CHAIN_WEBASSEMBLY_SOURCES}
 
              authority.cpp
+             finalizer_set.cpp
              trace.cpp
              transaction_metadata.cpp
              protocol_state_object.cpp

libraries/chain/abi_serializer.cpp

@@ -1,6 +1,7 @@
 #include <eosio/chain/abi_serializer.hpp>
 #include <eosio/chain/asset.hpp>
 #include <eosio/chain/exceptions.hpp>
+#include <eosio/chain/finalizer_authority.hpp>
 #include <fc/io/raw.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include <fc/io/varint.hpp>
@@ -632,6 +633,14 @@ namespace eosio { namespace chain {
       _variant_to_binary(type, var, ds, ctx);
    }
 
+   void impl::abi_to_variant::add_block_header_finalizer_set_extension( mutable_variant_object& mvo, const flat_multimap<uint16_t, block_header_extension>& header_exts ) {
+      if (header_exts.count(hs_finalizer_set_extension::extension_id())) {
+         const auto& finalizer_set_extension =
+                 std::get<hs_finalizer_set_extension>(header_exts.lower_bound(hs_finalizer_set_extension::extension_id())->second);
+         mvo("proposed_finalizer_set", finalizer_set_extension);
+      }
+   }
+
    type_name abi_serializer::get_action_type(name action)const {
       auto itr = actions.find(action);
       if( itr != actions.end() ) return itr->second;

libraries/chain/block_header.cpp

@@ -1,4 +1,5 @@
 #include <eosio/chain/block.hpp>
+#include <eosio/chain/finalizer_authority.hpp>
 #include <eosio/chain/merkle.hpp>
 #include <fc/io/raw.hpp>
 #include <fc/bitutil.hpp>
@@ -64,4 +65,28 @@ namespace eosio { namespace chain {
       return results;
    }
 
+   std::optional<block_header_extension> block_header::extract_header_extension(uint16_t extension_id)const {
+      using decompose_t = block_header_extension_types::decompose_t;
+
+      for( size_t i = 0; i < header_extensions.size(); ++i ) {
+         const auto& e = header_extensions[i];
+         auto id = e.first;
+
+         if (id != extension_id)
+            continue;
+
+         block_header_extension ext;
+
+         auto match = decompose_t::extract<block_header_extension>( id, e.second, ext );
+         EOS_ASSERT( match, invalid_block_header_extension,
+                     "Block header extension with id type ${id} is not supported",
+                     ("id", id)
+         );
+
+         return ext;
+      }
+
+      return {};
+   }
+
 } }

libraries/chain/block_header_state.cpp

@@ -4,6 +4,8 @@
 
 namespace eosio { namespace chain {
 
+#warning Add last_proposed_finalizer_set_generation to snapshot_block_header_state_v3, see header file TODO
+
    namespace detail {
       bool is_builtin_activated( const protocol_feature_activation_set_ptr& pfa,
                                  const protocol_feature_set& pfs,
@@ -65,6 +67,7 @@ namespace eosio { namespace chain {
 
       result.valid_block_signing_authority                   = proauth.authority;
       result.producer                                        = proauth.producer_name;
+      result.last_proposed_finalizer_set_generation          = last_proposed_finalizer_set_generation;
 
       result.blockroot_merkle = blockroot_merkle;
       result.blockroot_merkle.append( id );

libraries/chain/controller.cpp

@@ -27,6 +27,8 @@
 #include <eosio/chain/platform_timer.hpp>
 #include <eosio/chain/deep_mind.hpp>
 #include <eosio/chain/wasm_interface_collection.hpp>
+#include <eosio/chain/finalizer_set.hpp>
+#include <eosio/chain/finalizer_authority.hpp>
 
 #include <chainbase/chainbase.hpp>
 #include <eosio/vm/allocator.hpp>
@@ -263,6 +265,8 @@ struct controller_impl {
    map< account_name, map<handler_key, apply_handler> >   apply_handlers;
    unordered_map< builtin_protocol_feature_t, std::function<void(controller_impl&)>, enum_hash<builtin_protocol_feature_t> > protocol_feature_activation_handlers;
 
+   // TODO: This probably wants to be something better; store in chainbase and/or block_state
+   finalizer_set                current_finalizer_set;
 
    void pop_block() {
       auto prev = fork_db.get_block( head->header.previous );
@@ -340,6 +344,7 @@ struct controller_impl {
       set_activation_handler<builtin_protocol_feature_t::get_block_num>();
       set_activation_handler<builtin_protocol_feature_t::crypto_primitives>();
       set_activation_handler<builtin_protocol_feature_t::bls_primitives>();
+      set_activation_handler<builtin_protocol_feature_t::instant_finality>();
 
       self.irreversible_block.connect([this](const block_state_ptr& bsp) {
          wasm_if_collect.current_lib(bsp->block_num);
@@ -1900,6 +1905,18 @@ struct controller_impl {
 
       block_ptr->transactions = std::move( bb._pending_trx_receipts );
 
+      if (bb._pending_block_header_state.proposed_finalizer_set) {
+         // proposed_finalizer_set can't be set until builtin_protocol_feature_t::instant_finality activated
+         finalizer_set& fin_set = *bb._pending_block_header_state.proposed_finalizer_set;
+         ++bb._pending_block_header_state.last_proposed_finalizer_set_generation;
+         fin_set.generation = bb._pending_block_header_state.last_proposed_finalizer_set_generation;
+         emplace_extension(
+                 block_ptr->header_extensions,
+                 hs_finalizer_set_extension::extension_id(),
+                 fc::raw::pack( hs_finalizer_set_extension{ std::move(fin_set) } )
+         );
+      }
+
       auto id = block_ptr->calculate_id();
 
       // Update TaPoS table:
@@ -1973,6 +1990,13 @@ struct controller_impl {
       pending->push();
    }
 
+   void set_proposed_finalizers(const finalizer_set& fin_set) {
+      assert(pending); // has to exist and be building_block since called from host function
+      auto& bb = std::get<building_block>(pending->_block_stage);
+
+      bb._pending_block_header_state.proposed_finalizer_set.emplace(fin_set);
+   }
+
    /**
     *  This method is called from other threads. The controller_impl should outlive those threads.
     *  However, to avoid race conditions, it means that the behavior of this function should not change
@@ -3280,6 +3304,10 @@ int64_t controller::set_proposed_producers( vector<producer_authority> producers
    return version;
 }
 
+void controller::set_proposed_finalizers( const finalizer_set& fin_set ) {
+   my->set_proposed_finalizers(fin_set);
+}
+
 const producer_authority_schedule&    controller::active_producers()const {
    if( !(my->pending) )
       return  my->head->active_schedule;
@@ -3840,6 +3868,13 @@ void controller_impl::on_activation<builtin_protocol_feature_t::bls_primitives>(
    } );
 }
 
+template<>
+void controller_impl::on_activation<builtin_protocol_feature_t::instant_finality>() {
+   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "set_finalizers" );
+   } );
+}
+
 /// End of protocol feature activation handlers
 
 } } /// eosio::chain

libraries/chain/finalizer_set.cpp

@@ -0,0 +1,21 @@
+#include <eosio/chain/finalizer_set.hpp>
+#include <eosio/chain/finalizer_authority.hpp>
+#include <fc/crypto/bls_public_key.hpp>
+
+namespace eosio::chain {
+
+   /**
+    * These definitions are all here to avoid including bls_public_key.hpp which includes <bls12-381/bls12-381.hpp>
+    * and pulls in bls12-381 types. This keeps bls12-381 out of libtester.
+    */
+
+   finalizer_set::finalizer_set() = default;
+   finalizer_set::~finalizer_set() = default;
+
+   finalizer_set::finalizer_set(const finalizer_set&) = default;
+   finalizer_set::finalizer_set(finalizer_set&&) noexcept = default;
+
+   finalizer_set& finalizer_set::operator=(const finalizer_set&) = default;
+   finalizer_set& finalizer_set::operator=(finalizer_set&&) noexcept = default;
+
+} /// eosio::chain

libraries/chain/fork_database.cpp

@@ -17,8 +17,8 @@ namespace eosio { namespace chain {
 
    const uint32_t fork_database::magic_number = 0x30510FDB;
 
-   const uint32_t fork_database::min_supported_version = 1;
-   const uint32_t fork_database::max_supported_version = 1;
+   const uint32_t fork_database::min_supported_version = 2;
+   const uint32_t fork_database::max_supported_version = 2;
 
    // work around block_state::is_valid being private
    inline bool block_state_is_valid( const block_state& bs ) {
@@ -28,6 +28,7 @@ namespace eosio { namespace chain {
    /**
     * History:
     * Version 1: initial version of the new refactored fork database portable format
+    * Version 2: New format for block_state for hotstuff/instant-finality
     */
 
    struct by_block_id;

libraries/chain/include/eosio/chain/abi_serializer.hpp

@@ -636,6 +636,8 @@ namespace impl {
          out(name, std::move(mvo));
       }
 
+      static void add_block_header_finalizer_set_extension( mutable_variant_object& mvo, const flat_multimap<uint16_t, block_header_extension>& header_exts );
+
       /**
        * overload of to_variant_object for signed_block
        *
@@ -676,6 +678,7 @@ namespace impl {
                   std::get<producer_schedule_change_extension>(header_exts.lower_bound(producer_schedule_change_extension::extension_id())->second);
             mvo("new_producer_schedule", new_producer_schedule);
          }
+         add_block_header_finalizer_set_extension(mvo, header_exts);
 
          mvo("producer_signature", block.producer_signature);
          add(mvo, "transactions", block.transactions, resolver, ctx);

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

@@ -2,7 +2,9 @@
 #include <eosio/chain/block_timestamp.hpp>
 #include <eosio/chain/producer_schedule.hpp>
 #include <eosio/chain/protocol_feature_activation.hpp>
+#include <eosio/chain/finalizer_set.hpp>
 
+#include <optional>
 #include <type_traits>
 
 namespace eosio { namespace chain {
@@ -17,7 +19,8 @@ namespace eosio { namespace chain {
 
    using block_header_extension_types = detail::block_header_extension_types<
       protocol_feature_activation,
-      producer_schedule_change_extension
+      producer_schedule_change_extension,
+      hs_finalizer_set_extension
    >;
 
    using block_header_extension = block_header_extension_types::block_header_extension_t;
@@ -68,6 +71,7 @@ namespace eosio { namespace chain {
       static uint32_t   num_from_id(const block_id_type& id);
 
       flat_multimap<uint16_t, block_header_extension> 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

@@ -2,6 +2,7 @@
 #include <eosio/chain/block_header.hpp>
 #include <eosio/chain/incremental_merkle.hpp>
 #include <eosio/chain/protocol_feature_manager.hpp>
+#include <eosio/chain/finalizer_set.hpp>
 #include <eosio/chain/chain_snapshot.hpp>
 #include <future>
 
@@ -53,6 +54,7 @@ namespace detail {
       uint32_t                          dpos_proposed_irreversible_blocknum = 0;
       uint32_t                          dpos_irreversible_blocknum = 0;
       producer_authority_schedule       active_schedule;
+      uint32_t                          last_proposed_finalizer_set_generation = 0; // TODO: Add to snapshot_block_header_state_v3
       incremental_merkle                blockroot_merkle;
       flat_map<account_name,uint32_t>   producer_to_last_produced;
       flat_map<account_name,uint32_t>   producer_to_last_implied_irb;
@@ -74,6 +76,7 @@ namespace detail {
 struct pending_block_header_state : public detail::block_header_state_common {
    protocol_feature_activation_set_ptr  prev_activated_protocol_features;
    detail::schedule_info                prev_pending_schedule;
+   std::optional<finalizer_set>         proposed_finalizer_set; // set by set_finalizer host function
    bool                                 was_pending_promoted = false;
    block_id_type                        previous;
    account_name                         producer;
@@ -143,7 +146,6 @@ struct block_header_state : public detail::block_header_state_common {
                                                         const vector<digest_type>& )>& validator,
                               bool skip_validate_signee = false )const;
 
-   bool                 has_pending_producers()const { return pending_schedule.schedule.producers.size(); }
    uint32_t             calc_dpos_last_irreversible( account_name producer_of_next_block )const;
 
    producer_authority     get_scheduled_producer( block_timestamp_type t )const;
@@ -164,6 +166,7 @@ FC_REFLECT( eosio::chain::detail::block_header_state_common,
             (dpos_proposed_irreversible_blocknum)
             (dpos_irreversible_blocknum)
             (active_schedule)
+            (last_proposed_finalizer_set_generation)
             (blockroot_merkle)
             (producer_to_last_produced)
             (producer_to_last_implied_irb)

libraries/chain/include/eosio/chain/config.hpp

@@ -12,6 +12,7 @@ const static auto reversible_blocks_dir_name = "reversible";
 
 const static auto default_state_dir_name     = "state";
 const static auto forkdb_filename            = "fork_db.dat";
+const static auto qcdb_filename              = "qc_db.dat";
 const static auto default_state_size            = 1*1024*1024*1024ll;
 const static auto default_state_guard_size      =    128*1024*1024ll;
 
@@ -129,6 +130,11 @@ const static int max_producers = 125;
 const static size_t maximum_tracked_dpos_confirmations = 1024;     ///<
 static_assert(maximum_tracked_dpos_confirmations >= ((max_producers * 2 / 3) + 1) * producer_repetitions, "Settings never allow for DPOS irreversibility" );
 
+/**
+ * Maximum number of finalizers in the finalizer set
+ */
+const static size_t max_finalizers = 64*1024;
+const static size_t max_finalizer_description_size = 256;
 
 /**
  * The number of blocks produced per round is based upon all producers having a chance

libraries/chain/include/eosio/chain/controller.hpp

@@ -21,6 +21,8 @@ namespace eosio { namespace vm { class wasm_allocator; }}
 
 namespace eosio { namespace chain {
 
+   struct finalizer_set;
+
    class authorization_manager;
 
    namespace resource_limits {
@@ -166,7 +168,7 @@ namespace eosio { namespace chain {
          block_state_ptr finalize_block( block_report& br, const signer_callback_type& signer_callback );
          void sign_block( const signer_callback_type& signer_callback );
          void commit_block();
-
+         
          // thread-safe
          std::future<block_state_ptr> create_block_state_future( const block_id_type& id, const signed_block_ptr& b );
          // thread-safe
@@ -291,6 +293,9 @@ namespace eosio { namespace chain {
 
          int64_t set_proposed_producers( vector<producer_authority> producers );
 
+         // called by host function set_finalizers
+         void set_proposed_finalizers( const finalizer_set& fin_set );
+
          bool light_validation_allowed() const;
          bool skip_auth_check()const;
          bool skip_trx_checks()const;
@@ -338,16 +343,6 @@ namespace eosio { namespace chain {
          signal<void(std::tuple<const transaction_trace_ptr&, const packed_transaction_ptr&>)> applied_transaction;
          signal<void(const int&)>                      bad_alloc;
 
-         /*
-         signal<void()>                                  pre_apply_block;
-         signal<void()>                                  post_apply_block;
-         signal<void()>                                  abort_apply_block;
-         signal<void(const transaction_metadata_ptr&)>   pre_apply_transaction;
-         signal<void(const transaction_trace_ptr&)>      post_apply_transaction;
-         signal<void(const transaction_trace_ptr&)>  pre_apply_action;
-         signal<void(const transaction_trace_ptr&)>  post_apply_action;
-         */
-
          const apply_handler* find_apply_handler( account_name contract, scope_name scope, action_name act )const;
          wasm_interface_collection& get_wasm_interface();
 
@@ -376,7 +371,6 @@ namespace eosio { namespace chain {
          chainbase::database& mutable_db()const;
 
          std::unique_ptr<controller_impl> my;
-
    };
 
 } }  /// eosio::chain

libraries/chain/include/eosio/chain/finalizer_authority.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <fc/crypto/bls_public_key.hpp>
+#include <string>
+
+namespace eosio::chain {
+
+   struct finalizer_authority {
+
+      std::string  description;
+      uint64_t     fweight = 0; // weight that this finalizer's vote has for meeting fthreshold
+      fc::crypto::blslib::bls_public_key  public_key;
+
+      auto operator<=>(const finalizer_authority&) const = default;
+   };
+
+} /// eosio::chain
+
+FC_REFLECT( eosio::chain::finalizer_authority, (description)(fweight)(public_key) )