sysio::chain::pending_block_header_state Struct Reference

#include <block_header_state.hpp>

Inheritance diagram for sysio::chain::pending_block_header_state:

Collaboration diagram for sysio::chain::pending_block_header_state:

Public Member Functions
signed_block_header	make_block_header (const checksum256_type &transaction_mroot, const checksum256_type &action_mroot, const std::optional< producer_authority_schedule > &new_producers, vector< digest_type > &&new_protocol_feature_activations, const protocol_feature_set &pfs, const std::optional< s_header > &s_header) const
block_header_state	finish_next (const signed_block_header &h, vector< signature_type > &&additional_signatures, const protocol_feature_set &pfs, const std::function< void(block_timestamp_type, const flat_set< digest_type > &, const vector< digest_type > &)> &validator, bool skip_validate_signee=false) &&
block_header_state	finish_next (signed_block_header &h, const protocol_feature_set &pfs, const std::function< void(block_timestamp_type, const flat_set< digest_type > &, const vector< digest_type > &)> &validator, const signer_callback_type &signer) &&

Public Attributes
protocol_feature_activation_set_ptr	prev_activated_protocol_features
detail::schedule_info	prev_pending_schedule
bool	was_pending_promoted = false
block_id_type	previous
account_name	producer
block_timestamp_type	timestamp
uint32_t	active_schedule_version = 0
uint16_t	confirmed = 1
Public Attributes inherited from sysio::chain::detail::block_header_state_common
uint32_t	block_num = 0
uint32_t	dpos_proposed_irreversible_blocknum = 0
uint32_t	dpos_irreversible_blocknum = 0
producer_authority_schedule	active_schedule
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
block_signing_authority	valid_block_signing_authority
vector< uint8_t >	confirm_count

Protected Member Functions
block_header_state	_finish_next (const signed_block_header &h, const protocol_feature_set &pfs, const std::function< void(block_timestamp_type, const flat_set< digest_type > &, const vector< digest_type > &)> &validator) &&

Detailed Description

Definition at line 75 of file block_header_state.hpp.

Member Function Documentation

_finish_next()

block_header_state sysio::chain::pending_block_header_state::_finish_next ( const signed_block_header & h, const protocol_feature_set & pfs, const std::function< void(block_timestamp_type, const flat_set< digest_type > &, const vector< digest_type > &)> & validator ) &&

protected

Definition at line 234 of file block_header_state.cpp.

   {
      SYS_ASSERT( h.timestamp == timestamp, block_validate_exception, "timestamp mismatch" );
      SYS_ASSERT( h.previous == previous, unlinkable_block_exception, "previous mismatch" );
      SYS_ASSERT( h.confirmed == confirmed, block_validate_exception, "confirmed mismatch" );
      SYS_ASSERT( h.producer == producer, wrong_producer, "wrong producer specified" );
      SYS_ASSERT( h.schedule_version == active_schedule_version, producer_schedule_exception, "schedule_version in signed block is corrupted" );
 
      auto exts = h.validate_and_extract_header_extensions();
 
      std::optional<producer_authority_schedule> maybe_new_producer_schedule;
      std::optional<digest_type> maybe_new_producer_schedule_hash;
      bool wtmsig_enabled = false;
 
      if (h.new_producers || exts.count(producer_schedule_change_extension::extension_id()) > 0 ) {
         wtmsig_enabled = detail::is_builtin_activated(prev_activated_protocol_features, pfs, builtin_protocol_feature_t::wtmsig_block_signatures);
      }
 
      if( h.new_producers ) {
         SYS_ASSERT(!wtmsig_enabled, producer_schedule_exception, "Block header contains legacy producer schedule outdated by activation of WTMsig Block Signatures" );
 
         SYS_ASSERT( !was_pending_promoted, producer_schedule_exception, "cannot set pending producer schedule in the same block in which pending was promoted to active" );
 
         const auto& new_producers = *h.new_producers;
         SYS_ASSERT( new_producers.version == active_schedule.version + 1, producer_schedule_exception, "wrong producer schedule version specified" );
         SYS_ASSERT( prev_pending_schedule.schedule.producers.empty(), producer_schedule_exception,
                    "cannot set new pending producers until last pending is confirmed" );
 
         maybe_new_producer_schedule_hash.emplace(digest_type::hash(new_producers));
         maybe_new_producer_schedule.emplace(new_producers);
      }
 
      if ( exts.count(producer_schedule_change_extension::extension_id()) > 0 ) {
         SYS_ASSERT(wtmsig_enabled, producer_schedule_exception, "Block header producer_schedule_change_extension before activation of WTMsig Block Signatures" );
         SYS_ASSERT( !was_pending_promoted, producer_schedule_exception, "cannot set pending producer schedule in the same block in which pending was promoted to active" );
 
         const auto& new_producer_schedule = std::get<producer_schedule_change_extension>(exts.lower_bound(producer_schedule_change_extension::extension_id())->second);
 
         SYS_ASSERT( new_producer_schedule.version == active_schedule.version + 1, producer_schedule_exception, "wrong producer schedule version specified" );
         SYS_ASSERT( prev_pending_schedule.schedule.producers.empty(), producer_schedule_exception,
                     "cannot set new pending producers until last pending is confirmed" );
 
         maybe_new_producer_schedule_hash.emplace(digest_type::hash(new_producer_schedule));
         maybe_new_producer_schedule.emplace(new_producer_schedule);
      }
 
      protocol_feature_activation_set_ptr new_activated_protocol_features;
      { // handle protocol_feature_activation
         if( exts.count(protocol_feature_activation::extension_id() > 0) ) {
            const auto& new_protocol_features = std::get<protocol_feature_activation>(exts.lower_bound(protocol_feature_activation::extension_id())->second).protocol_features;
            validator( timestamp, prev_activated_protocol_features->protocol_features, new_protocol_features );
 
            new_activated_protocol_features =   std::make_shared<protocol_feature_activation_set>(
                                                   *prev_activated_protocol_features,
                                                   new_protocol_features
                                                );
         } else {
            new_activated_protocol_features = std::move( prev_activated_protocol_features );
         }
      }
 
      auto block_number = block_num;
 
      block_header_state result( std::move( *static_cast<detail::block_header_state_common*>(this) ) );
 
      result.id      = h.calculate_id();
      result.header  = h;
 
      result.header_exts = std::move(exts);
 
      if( maybe_new_producer_schedule ) {
         result.pending_schedule.schedule = std::move(*maybe_new_producer_schedule);
         result.pending_schedule.schedule_hash = std::move(*maybe_new_producer_schedule_hash);
         result.pending_schedule.schedule_lib_num    = block_number;
      } else {
         if( was_pending_promoted ) {
            result.pending_schedule.schedule.version = prev_pending_schedule.schedule.version;
         } else {
            result.pending_schedule.schedule         = std::move( prev_pending_schedule.schedule );
         }
         result.pending_schedule.schedule_hash       = std::move( prev_pending_schedule.schedule_hash );
         result.pending_schedule.schedule_lib_num    = prev_pending_schedule.schedule_lib_num;
      }
 
      result.activated_protocol_features = std::move( new_activated_protocol_features );
 
      return result;
   }

Here is the call graph for this function:

finish_next() [1/2]

block_header_state sysio::chain::pending_block_header_state::finish_next	(	const signed_block_header &	h,
		vector< signature_type > &&	additional_signatures,
		const protocol_feature_set &	pfs,
		const std::function< void(block_timestamp_type, const flat_set< digest_type > &, const vector< digest_type > &)> &	validator,
		bool	skip_validate_signee = false ) &&

Definition at line 330 of file block_header_state.cpp.

   {
      if( !additional_signatures.empty() ) {
         bool wtmsig_enabled = detail::is_builtin_activated(prev_activated_protocol_features, pfs, builtin_protocol_feature_t::wtmsig_block_signatures);
 
         SYS_ASSERT(wtmsig_enabled, producer_schedule_exception, "Block contains multiple signatures before WTMsig block signatures are enabled" );
      }
 
      auto result = std::move(*this)._finish_next( h, pfs, validator );
 
      if( !additional_signatures.empty() ) {
         result.additional_signatures = std::move(additional_signatures);
      }
 
      // ASSUMPTION FROM controller_impl::apply_block = all untrusted blocks will have their signatures pre-validated here
      if( !skip_validate_signee ) {
        result.verify_signee( );
      }
 
      return result;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

finish_next() [2/2]

block_header_state sysio::chain::pending_block_header_state::finish_next	(	signed_block_header &	h,
		const protocol_feature_set &	pfs,
		const std::function< void(block_timestamp_type, const flat_set< digest_type > &, const vector< digest_type > &)> &	validator,
		const signer_callback_type &	signer ) &&

Definition at line 360 of file block_header_state.cpp.

   {
      auto pfa = prev_activated_protocol_features;
 
      auto result = std::move(*this)._finish_next( h, pfs, validator );
      result.sign( signer );
      h.producer_signature = result.header.producer_signature;
 
      if( !result.additional_signatures.empty() ) {
         bool wtmsig_enabled = detail::is_builtin_activated(pfa, pfs, builtin_protocol_feature_t::wtmsig_block_signatures);
         SYS_ASSERT(wtmsig_enabled, producer_schedule_exception, "Block was signed with multiple signatures before WTMsig block signatures are enabled" );
      }
 
      return result;
   }

Here is the call graph for this function:

make_block_header()

signed_block_header sysio::chain::pending_block_header_state::make_block_header	(	const checksum256_type &	transaction_mroot,
		const checksum256_type &	action_mroot,
		const std::optional< producer_authority_schedule > &	new_producers,
		vector< digest_type > &&	new_protocol_feature_activations,
		const protocol_feature_set &	pfs,
		const std::optional< s_header > &	s_header ) const

Definition at line 173 of file block_header_state.cpp.

   {
      signed_block_header h;
 
      h.timestamp         = timestamp;
      h.producer          = producer;
      h.confirmed         = confirmed;
      h.previous          = previous;
      h.transaction_mroot = transaction_mroot;
      h.action_mroot      = action_mroot;
      h.schedule_version  = active_schedule_version;
 
      if( new_protocol_feature_activations.size() > 0 ) {
         emplace_extension(
               h.header_extensions,
               protocol_feature_activation::extension_id(),
               fc::raw::pack( protocol_feature_activation{ std::move(new_protocol_feature_activations) } )
         );
      }
 
      if (new_producers) {
         if ( detail::is_builtin_activated(prev_activated_protocol_features, pfs, builtin_protocol_feature_t::wtmsig_block_signatures) ) {
            // add the header extension to update the block schedule
            emplace_extension(
                  h.header_extensions,
                  producer_schedule_change_extension::extension_id(),
                  fc::raw::pack( producer_schedule_change_extension( *new_producers ) )
            );
         } else {
            legacy::producer_schedule_type downgraded_producers;
            downgraded_producers.version = new_producers->version;
            for (const auto &p : new_producers->producers) {
               std::visit([&downgraded_producers, &p](const auto& auth)
               {
                  SYS_ASSERT(auth.keys.size() == 1 && auth.keys.front().weight == auth.threshold, producer_schedule_exception, "multisig block signing present before enabled!");
                  downgraded_producers.producers.emplace_back(legacy::producer_key{p.producer_name, auth.keys.front().key});
               }, p.authority);
            }
            h.new_producers = std::move(downgraded_producers);
         }
      }
      
      // Add s_root_extension to header extensions if present & relevant
      if (s_header) {
         emplace_extension(
            h.header_extensions,
            s_root_extension::extension_id(),
            fc::raw::pack( s_root_extension ( *s_header ))
         );
      }
 
      return h;
   }

Here is the call graph for this function:

Member Data Documentation

active_schedule_version

uint32_t sysio::chain::pending_block_header_state::active_schedule_version = 0

Definition at line 82 of file block_header_state.hpp.

confirmed

uint16_t sysio::chain::pending_block_header_state::confirmed = 1

Definition at line 83 of file block_header_state.hpp.

prev_activated_protocol_features

protocol_feature_activation_set_ptr sysio::chain::pending_block_header_state::prev_activated_protocol_features

Definition at line 76 of file block_header_state.hpp.

prev_pending_schedule

detail::schedule_info sysio::chain::pending_block_header_state::prev_pending_schedule

Definition at line 77 of file block_header_state.hpp.

previous

block_id_type sysio::chain::pending_block_header_state::previous

Definition at line 79 of file block_header_state.hpp.

producer

account_name sysio::chain::pending_block_header_state::producer

Definition at line 80 of file block_header_state.hpp.

timestamp

block_timestamp_type sysio::chain::pending_block_header_state::timestamp

Definition at line 81 of file block_header_state.hpp.

was_pending_promoted

bool sysio::chain::pending_block_header_state::was_pending_promoted = false

Definition at line 78 of file block_header_state.hpp.

---

The documentation for this struct was generated from the following files:

• libraries/chain/include/sysio/chain/block_header_state.hpp
• libraries/chain/block_header_state.cpp