IF: Remove block_state_legacy access

libraries/chain/controller.cpp

@@ -3524,6 +3524,9 @@ void controller::set_disable_replay_opts( bool v ) {
 uint32_t controller::head_block_num()const {
    return my->head->block_num();
 }
+block_timestamp_type controller::head_block_timestamp()const {
+   return my->head->header.timestamp;
+}
 time_point controller::head_block_time()const {
    return my->head->header.timestamp;
 }
@@ -3536,9 +3539,13 @@ account_name  controller::head_block_producer()const {
 const block_header& controller::head_block_header()const {
    return my->head->header;
 }
-block_state_legacy_ptr controller::head_block_state()const {
+block_state_legacy_ptr controller::head_block_state_legacy()const {
+   // TODO: return null after instant finality activated
    return my->head;
 }
+const signed_block_ptr& controller::head_block()const {
+   return my->head->block;
+}
 
 block_state_legacy_ptr controller_impl::fork_db_head() const {
    if( read_mode == db_read_mode::IRREVERSIBLE ) {
@@ -3632,7 +3639,7 @@ std::optional<signed_block_header> controller::fetch_block_header_by_id( const b
 }
 
 signed_block_ptr controller::fetch_block_by_number( uint32_t block_num )const  { try {
-   auto blk_state = fetch_block_state_by_number( block_num );
+   auto blk_state = my->fork_db.search_on_branch( fork_db_head_block_id(), block_num );
    if( blk_state ) {
       return blk_state->block;
    }
@@ -3641,30 +3648,21 @@ signed_block_ptr controller::fetch_block_by_number( uint32_t block_num )const  {
 } FC_CAPTURE_AND_RETHROW( (block_num) ) }
 
 std::optional<signed_block_header> controller::fetch_block_header_by_number( uint32_t block_num )const  { try {
-   auto blk_state = fetch_block_state_by_number( block_num );
+   auto blk_state = my->fork_db.search_on_branch( fork_db_head_block_id(), block_num );
    if( blk_state ) {
       return blk_state->header;
    }
 
    return my->blog.read_block_header_by_num(block_num);
 } FC_CAPTURE_AND_RETHROW( (block_num) ) }
 
-block_state_legacy_ptr controller::fetch_block_state_by_id( block_id_type id )const {
-   auto state = my->fork_db.get_block(id);
-   return state;
-}
-
-block_state_legacy_ptr controller::fetch_block_state_by_number( uint32_t block_num )const  { try {
-   return my->fork_db.search_on_branch( fork_db_head_block_id(), block_num );
-} FC_CAPTURE_AND_RETHROW( (block_num) ) }
-
 block_id_type controller::get_block_id_for_num( uint32_t block_num )const { try {
    const auto& blog_head = my->blog.head();
 
    bool find_in_blog = (blog_head && block_num <= blog_head->block_num());
 
    if( !find_in_blog ) {
-      auto bsp = fetch_block_state_by_number( block_num );
+      auto bsp = my->fork_db.search_on_branch( fork_db_head_block_id(), block_num );
       if( bsp ) return bsp->id();
    }
 

libraries/chain/hotstuff/chain_pacemaker.cpp

@@ -118,7 +118,8 @@ namespace eosio::chain {
          const auto& [ block, id ] = t;
          on_irreversible_block( block );
       } );
-      _head_block_state = chain->head_block_state();
+      // TODO: assuming this will be going away
+      _head_block_state = chain->head_block_state_legacy();
    }
 
    void chain_pacemaker::register_bcast_function(std::function<void(const std::optional<uint32_t>&, const hs_message&)> broadcast_hs_message) {
@@ -161,7 +162,8 @@ namespace eosio::chain {
    // called from main thread
    void chain_pacemaker::on_accepted_block( const signed_block_ptr& block ) {
       std::scoped_lock g( _chain_state_mutex );
-      _head_block_state = _chain->fetch_block_state_by_number(block->block_num());
+      // TODO: assume this is going away
+      _head_block_state = _chain->head_block_state_legacy();
    }
 
    // called from main thread

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

@@ -230,10 +230,13 @@ namespace eosio::chain {
 
          uint32_t             head_block_num()const;
          time_point           head_block_time()const;
+         block_timestamp_type head_block_timestamp()const;
          block_id_type        head_block_id()const;
          account_name         head_block_producer()const;
          const block_header&  head_block_header()const;
-         block_state_legacy_ptr head_block_state()const;
+         const signed_block_ptr& head_block()const;
+         // returns nullptr after instant finality enabled
+         block_state_legacy_ptr head_block_state_legacy()const;
 
          uint32_t             fork_db_head_block_num()const;
          block_id_type        fork_db_head_block_id()const;
@@ -265,10 +268,6 @@ namespace eosio::chain {
          std::optional<signed_block_header> fetch_block_header_by_number( uint32_t block_num )const;
          // thread-safe
          std::optional<signed_block_header> fetch_block_header_by_id( const block_id_type& id )const;
-         // return block_state_legacy from forkdb, thread-safe
-         block_state_legacy_ptr fetch_block_state_by_number( uint32_t block_num )const;
-         // return block_state_legacy from forkdb, thread-safe
-         block_state_legacy_ptr fetch_block_state_by_id( block_id_type id )const;
          // thread-safe
          block_id_type get_block_id_for_num( uint32_t block_num )const;
 

libraries/chain/include/eosio/chain/producer_schedule.hpp

@@ -1,6 +1,7 @@
 #pragma once
 #include <eosio/chain/config.hpp>
 #include <eosio/chain/types.hpp>
+#include <eosio/chain/block_timestamp.hpp>
 #include <chainbase/chainbase.hpp>
 #include <eosio/chain/authority.hpp>
 #include <eosio/chain/snapshot.hpp>
@@ -249,6 +250,12 @@ namespace eosio { namespace chain {
       uint32_t                                       version = 0; ///< sequentially incrementing version number
       vector<producer_authority>                     producers;
 
+      const producer_authority& get_scheduled_producer( block_timestamp_type t )const {
+         auto index = t.slot % (producers.size() * config::producer_repetitions);
+         index /= config::producer_repetitions;
+         return producers[index];
+      }
+
       friend bool operator == ( const producer_authority_schedule& a, const producer_authority_schedule& b )
       {
          if( a.version != b.version ) return false;

libraries/testing/include/eosio/testing/tester.hpp

@@ -640,8 +640,8 @@ namespace eosio { namespace testing {
       bool validate() {
 
 
-        auto hbh = control->head_block_state()->header;
-        auto vn_hbh = validating_node->head_block_state()->header;
+        const auto& hbh = control->head_block_header();
+        const auto& vn_hbh = validating_node->head_block_header();
         bool ok = control->head_block_id() == validating_node->head_block_id() &&
                hbh.previous == vn_hbh.previous &&
                hbh.timestamp == vn_hbh.timestamp &&

libraries/testing/tester.cpp

@@ -398,7 +398,6 @@ namespace eosio { namespace testing {
 
    signed_block_ptr base_tester::_produce_block( fc::microseconds skip_time, bool skip_pending_trxs,
                                                  bool no_throw, std::vector<transaction_trace_ptr>& traces ) {
-      auto head = control->head_block_state();
       auto head_time = control->head_block_time();
       auto next_time = head_time + skip_time;
 
@@ -438,7 +437,7 @@ namespace eosio { namespace testing {
 
    void base_tester::_start_block(fc::time_point block_time) {
       auto head_block_number = control->head_block_num();
-      auto producer = control->head_block_state()->get_scheduled_producer(block_time);
+      auto producer = control->active_producers().get_scheduled_producer(block_time);
 
       auto last_produced_block_num = control->last_irreversible_block_num();
       auto itr = last_produced_block.find(producer.producer_name);
@@ -473,16 +472,17 @@ namespace eosio { namespace testing {
    signed_block_ptr base_tester::_finish_block() {
       FC_ASSERT( control->is_building_block(), "must first start a block before it can be finished" );
 
-      auto producer = control->head_block_state()->get_scheduled_producer( control->pending_block_time() );
+      auto auth = control->pending_block_signing_authority();
+      auto producer_name = control->pending_block_producer();
       vector<private_key_type> signing_keys;
 
-      auto default_active_key = get_public_key( producer.producer_name, "active");
-      producer.for_each_key([&](const public_key_type& key){
+      auto default_active_key = get_public_key( producer_name, "active");
+      producer_authority::for_each_key(auth, [&](const public_key_type& key){
          const auto& iter = block_signing_private_keys.find(key);
          if(iter != block_signing_private_keys.end()) {
             signing_keys.push_back(iter->second);
          } else if (key == default_active_key) {
-            signing_keys.emplace_back( get_private_key( producer.producer_name, "active") );
+            signing_keys.emplace_back( get_private_key( producer_name, "active") );
          }
       });
 
@@ -497,9 +497,9 @@ namespace eosio { namespace testing {
       } );
 
       control->commit_block();
-      last_produced_block[control->head_block_state()->header.producer] = control->head_block_state()->id();
+      last_produced_block[producer_name] = control->head_block_id();
 
-      return control->head_block_state()->block;
+      return control->head_block();
    }
 
    signed_block_ptr base_tester::produce_block( std::vector<transaction_trace_ptr>& traces ) {
@@ -547,7 +547,7 @@ namespace eosio { namespace testing {
    void base_tester::produce_min_num_of_blocks_to_spend_time_wo_inactive_prod(const fc::microseconds target_elapsed_time) {
       fc::microseconds elapsed_time;
       while (elapsed_time < target_elapsed_time) {
-         for(uint32_t i = 0; i < control->head_block_state()->active_schedule.producers.size(); i++) {
+         for(uint32_t i = 0; i < control->active_producers().producers.size(); i++) {
             const auto time_to_skip = fc::milliseconds(config::producer_repetitions * config::block_interval_ms);
             produce_block(time_to_skip);
             elapsed_time += time_to_skip;

plugins/chain_api_plugin/chain.swagger.yaml

@@ -186,30 +186,6 @@ paths:
               schema:
                 description: Returns Nothing
 
-  /get_block_header_state:
-    post:
-      description: Retrieves the glock header state
-      operationId: get_block_header_state
-      requestBody:
-        content:
-          application/json:
-            schema:
-              type: object
-              required:
-                - block_num_or_id
-              properties:
-                block_num_or_id:
-                  type: string
-                  description: Provide a block_number or a block_id
-
-      responses:
-        "200":
-          description: OK
-          content:
-            application/json:
-              schema:
-                $ref: "https://docs.eosnetwork.com/openapi/v2.0/BlockHeaderState.yaml"
-
   /get_abi:
     post:
       description: Retrieves the ABI for a contract based on its account name

plugins/chain_api_plugin/chain_api_plugin.cpp

@@ -132,7 +132,6 @@ void chain_api_plugin::plugin_startup() {
       CHAIN_RO_CALL(get_activated_protocol_features, 200, http_params_types::possible_no_params),
       CHAIN_RO_CALL_POST(get_block, fc::variant, 200, http_params_types::params_required), // _POST because get_block() returns a lambda to be executed on the http thread pool
       CHAIN_RO_CALL(get_block_info, 200, http_params_types::params_required),
-      CHAIN_RO_CALL(get_block_header_state, 200, http_params_types::params_required),
       CHAIN_RO_CALL_POST(get_account, chain_apis::read_only::get_account_results, 200, http_params_types::params_required),
       CHAIN_RO_CALL(get_code, 200, http_params_types::params_required),
       CHAIN_RO_CALL(get_code_hash, 200, http_params_types::params_required),

plugins/chain_plugin/chain_plugin.cpp

@@ -1984,9 +1984,9 @@ fc::variant read_only::convert_block( const chain::signed_block_ptr& block, abi_
 
 fc::variant read_only::get_block_info(const read_only::get_block_info_params& params, const fc::time_point&) const {
 
-   signed_block_ptr block;
+   std::optional<signed_block_header> block;
    try {
-         block = db.fetch_block_by_number( params.block_num );
+         block = db.fetch_block_header_by_number( params.block_num );
    } catch (...)   {
       // assert below will handle the invalid block num
    }
@@ -2011,29 +2011,6 @@ fc::variant read_only::get_block_info(const read_only::get_block_info_params& pa
          ("ref_block_prefix", ref_block_prefix);
 }
 
-fc::variant read_only::get_block_header_state(const get_block_header_state_params& params, const fc::time_point&) const {
-   block_state_legacy_ptr b;
-   std::optional<uint64_t> block_num;
-   std::exception_ptr e;
-   try {
-      block_num = fc::to_uint64(params.block_num_or_id);
-   } catch( ... ) {}
-
-   if( block_num ) {
-      b = db.fetch_block_state_by_number(*block_num);
-   } else {
-      try {
-         b = db.fetch_block_state_by_id(fc::variant(params.block_num_or_id).as<block_id_type>());
-      } EOS_RETHROW_EXCEPTIONS(chain::block_id_type_exception, "Invalid block ID: ${block_num_or_id}", ("block_num_or_id", params.block_num_or_id))
-   }
-
-   EOS_ASSERT( b, unknown_block_exception, "Could not find reversible block: ${block}", ("block", params.block_num_or_id));
-
-   fc::variant vo;
-   fc::to_variant( static_cast<const block_header_state_legacy&>(*b), vo );
-   return vo;
-}
-
 void read_write::push_block(read_write::push_block_params&& params, next_function<read_write::push_block_results> next) {
    try {
       app().get_method<incoming::methods::block_sync>()(std::make_shared<signed_block>( std::move(params) ), std::optional<block_id_type>{}, block_state_legacy_ptr{});

plugins/chain_plugin/include/eosio/chain_plugin/chain_plugin.hpp

@@ -409,12 +409,6 @@ class read_only : public api_base {
 
    fc::variant get_block_info(const get_block_info_params& params, const fc::time_point& deadline) const;
 
-   struct get_block_header_state_params {
-      string block_num_or_id;
-   };
-
-   fc::variant get_block_header_state(const get_block_header_state_params& params, const fc::time_point& deadline) const;
-
    struct get_table_rows_params {
       bool                 json = false;
       name                 code;
@@ -1067,7 +1061,6 @@ FC_REFLECT(eosio::chain_apis::read_only::get_activated_protocol_features_params,
 FC_REFLECT(eosio::chain_apis::read_only::get_activated_protocol_features_results, (activated_protocol_features)(more) )
 FC_REFLECT(eosio::chain_apis::read_only::get_raw_block_params, (block_num_or_id))
 FC_REFLECT(eosio::chain_apis::read_only::get_block_info_params, (block_num))
-FC_REFLECT(eosio::chain_apis::read_only::get_block_header_state_params, (block_num_or_id))
 FC_REFLECT(eosio::chain_apis::read_only::get_block_header_params, (block_num_or_id)(include_extensions))
 FC_REFLECT(eosio::chain_apis::read_only::get_block_header_result, (id)(signed_block_header)(block_extensions))
 

plugins/net_plugin/net_plugin.cpp

@@ -3711,7 +3711,7 @@ namespace eosio {
          controller& cc = my_impl->chain_plug->chain();
 
          // may have come in on a different connection and posted into dispatcher strand before this one
-         if( my_impl->dispatcher->have_block( id ) || cc.fetch_block_state_by_id( id ) ) { // thread-safe
+         if( my_impl->dispatcher->have_block( id ) || cc.fetch_block_by_id( id ) ) { // thread-safe
             my_impl->dispatcher->add_peer_block( id, c->connection_id );
             c->strand.post( [c, id]() {
                my_impl->sync_master->sync_recv_block( c, id, block_header::num_from_id(id), false );