sysio::chain::block_header_state Struct Reference

defines the minimum state necessary to validate transaction headers More...

#include <block_header_state.hpp>

Inheritance diagram for sysio::chain::block_header_state:

Collaboration diagram for sysio::chain::block_header_state:

Public Member Functions
	block_header_state ()=default
	block_header_state (detail::block_header_state_common &&base)
	block_header_state (legacy::snapshot_block_header_state_v2 &&snapshot)
pending_block_header_state	next (block_timestamp_type when, uint16_t num_prev_blocks_to_confirm) const
block_header_state	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) const
bool	has_pending_producers () const
uint32_t	calc_dpos_last_irreversible (account_name producer_of_next_block) const
producer_authority	get_scheduled_producer (block_timestamp_type t) const
const block_id_type &	prev () const
digest_type	sig_digest () const
void	sign (const signer_callback_type &signer)
void	verify_signee () const
const vector< digest_type > &	get_new_protocol_feature_activations () const

Public Attributes
block_id_type	id
signed_block_header	header
detail::schedule_info	pending_schedule
protocol_feature_activation_set_ptr	activated_protocol_features
vector< signature_type >	additional_signatures
flat_multimap< uint16_t, block_header_extension >	header_exts
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

Detailed Description

Definition at line 119 of file block_header_state.hpp.

Constructor & Destructor Documentation

block_header_state() [1/3]

sysio::chain::block_header_state::block_header_state ( )

default

block_header_state() [2/3]

sysio::chain::block_header_state::block_header_state ( detail::block_header_state_common && base )

inlineexplicit

Definition at line 132 of file block_header_state.hpp.

   :detail::block_header_state_common( std::move(base) )
   {}

block_header_state() [3/3]

sysio::chain::block_header_state::block_header_state ( legacy::snapshot_block_header_state_v2 && snapshot )

explicit

Definition at line 466 of file block_header_state.cpp.

   {
      block_num                             = snapshot.block_num;
      dpos_proposed_irreversible_blocknum   = snapshot.dpos_proposed_irreversible_blocknum;
      dpos_irreversible_blocknum            = snapshot.dpos_irreversible_blocknum;
      active_schedule                       = producer_authority_schedule( snapshot.active_schedule );
      blockroot_merkle                      = std::move(snapshot.blockroot_merkle);
      producer_to_last_produced             = std::move(snapshot.producer_to_last_produced);
      producer_to_last_implied_irb          = std::move(snapshot.producer_to_last_implied_irb);
      valid_block_signing_authority         = block_signing_authority_v0{ 1, {{std::move(snapshot.block_signing_key), 1}} };
      confirm_count                         = std::move(snapshot.confirm_count);
      id                                    = std::move(snapshot.id);
      header                                = std::move(snapshot.header);
      pending_schedule.schedule_lib_num     = snapshot.pending_schedule.schedule_lib_num;
      pending_schedule.schedule_hash        = std::move(snapshot.pending_schedule.schedule_hash);
      pending_schedule.schedule             = producer_authority_schedule( snapshot.pending_schedule.schedule );
      activated_protocol_features           = std::move(snapshot.activated_protocol_features);
   }

Member Function Documentation

calc_dpos_last_irreversible()

uint32_t sysio::chain::block_header_state::calc_dpos_last_irreversible

(

account_name

producer_of_next_block

)

const

2/3 must be greater, so if I go 1/3 into the list sorted from low to high, then 2/3 are greater

Definition at line 24 of file block_header_state.cpp.

                                                                                                      {
      vector<uint32_t> blocknums; blocknums.reserve( producer_to_last_implied_irb.size() );
      for( auto& i : producer_to_last_implied_irb ) {
         blocknums.push_back( (i.first == producer_of_next_block) ? dpos_proposed_irreversible_blocknum : i.second);
      }
 
      if( blocknums.size() == 0 ) return 0;
 
      std::size_t index = (blocknums.size()-1) / 3;
      std::nth_element( blocknums.begin(),  blocknums.begin() + index, blocknums.end() );
      return blocknums[ index ];
   }

Here is the caller graph for this function:

get_new_protocol_feature_activations()

const vector< digest_type > & sysio::chain::block_header_state::get_new_protocol_feature_activations

(

)

const

Reference cannot outlive *this. Assumes header_exts is not mutated after instatiation.

Definition at line 457 of file block_header_state.cpp.

                                                                                            {
      static const vector<digest_type> no_activations{};
 
      if( header_exts.count(protocol_feature_activation::extension_id()) == 0 )
         return no_activations;
 
      return std::get<protocol_feature_activation>(header_exts.lower_bound(protocol_feature_activation::extension_id())->second).protocol_features;
   }

Here is the call graph for this function:

get_scheduled_producer()

producer_authority sysio::chain::block_header_state::get_scheduled_producer

(

block_timestamp_type

t

)

const

Definition at line 18 of file block_header_state.cpp.

                                                                                              {
      auto index = t.slot % (active_schedule.producers.size() * config::producer_repetitions);
      index /= config::producer_repetitions;
      return active_schedule.producers[index];
   }

Here is the caller graph for this function:

has_pending_producers()

bool sysio::chain::block_header_state::has_pending_producers ( ) const

inline

Definition at line 148 of file block_header_state.hpp.

{ return pending_schedule.schedule.producers.size(); }

next() [1/2]

pending_block_header_state sysio::chain::block_header_state::next	(	block_timestamp_type	when,
		uint16_t	num_prev_blocks_to_confirm ) const

grow the confirmed count

confirm the head block too

Definition at line 38 of file block_header_state.cpp.

   {
      pending_block_header_state result;
 
      if( when != block_timestamp_type() ) {
        SYS_ASSERT( when > header.timestamp, block_validate_exception, "next block must be in the future" );
      } else {
        (when = header.timestamp).slot++;
      }
 
      auto proauth = get_scheduled_producer(when);
 
      auto itr = producer_to_last_produced.find( proauth.producer_name );
      if( itr != producer_to_last_produced.end() ) {
        SYS_ASSERT( itr->second < (block_num+1) - num_prev_blocks_to_confirm, producer_double_confirm,
                    "producer ${prod} double-confirming known range",
                    ("prod", proauth.producer_name)("num", block_num+1)
                    ("confirmed", num_prev_blocks_to_confirm)("last_produced", itr->second) );
      }
 
      result.block_num                                       = block_num + 1;
      result.previous                                        = id;
      result.timestamp                                       = when;
      result.confirmed                                       = num_prev_blocks_to_confirm;
      result.active_schedule_version                         = active_schedule.version;
      result.prev_activated_protocol_features                = activated_protocol_features;
 
      result.valid_block_signing_authority                   = proauth.authority;
      result.producer                                        = proauth.producer_name;
 
      result.blockroot_merkle = blockroot_merkle;
      result.blockroot_merkle.append( id );
 
      static_assert(std::numeric_limits<uint8_t>::max() >= (config::max_producers * 2 / 3) + 1, "8bit confirmations may not be able to hold all of the needed confirmations");
 
      // This uses the previous block active_schedule because thats the "schedule" that signs and therefore confirms _this_ block
      auto num_active_producers = active_schedule.producers.size();
      uint32_t required_confs = (uint32_t)(num_active_producers * 2 / 3) + 1;
 
      if( confirm_count.size() < config::maximum_tracked_dpos_confirmations ) {
         result.confirm_count.reserve( confirm_count.size() + 1 );
         result.confirm_count  = confirm_count;
         result.confirm_count.resize( confirm_count.size() + 1 );
         result.confirm_count.back() = (uint8_t)required_confs;
      } else {
         result.confirm_count.resize( confirm_count.size() );
         memcpy( &result.confirm_count[0], &confirm_count[1], confirm_count.size() - 1 );
         result.confirm_count.back() = (uint8_t)required_confs;
      }
 
      auto new_dpos_proposed_irreversible_blocknum = dpos_proposed_irreversible_blocknum;
 
      int32_t i = (int32_t)(result.confirm_count.size() - 1);
      uint32_t blocks_to_confirm = num_prev_blocks_to_confirm + 1; 
      while( i >= 0 && blocks_to_confirm ) {
        --result.confirm_count[i];
        //idump((confirm_count[i]));
        if( result.confirm_count[i] == 0 )
        {
            uint32_t block_num_for_i = result.block_num - (uint32_t)(result.confirm_count.size() - 1 - i);
            new_dpos_proposed_irreversible_blocknum = block_num_for_i;
            //idump((dpos2_lib)(block_num)(dpos_irreversible_blocknum));
 
            if (i == static_cast<int32_t>(result.confirm_count.size() - 1)) {
               result.confirm_count.resize(0);
            } else {
               memmove( &result.confirm_count[0], &result.confirm_count[i + 1], result.confirm_count.size() - i  - 1);
               result.confirm_count.resize( result.confirm_count.size() - i - 1 );
            }
 
            break;
        }
        --i;
        --blocks_to_confirm;
      }
 
      result.dpos_proposed_irreversible_blocknum   = new_dpos_proposed_irreversible_blocknum;
      result.dpos_irreversible_blocknum            = calc_dpos_last_irreversible( proauth.producer_name );
 
      result.prev_pending_schedule                 = pending_schedule;
 
      if( pending_schedule.schedule.producers.size() &&
          result.dpos_irreversible_blocknum >= pending_schedule.schedule_lib_num )
      {
         result.active_schedule = pending_schedule.schedule;
 
         flat_map<account_name,uint32_t> new_producer_to_last_produced;
 
         for( const auto& pro : result.active_schedule.producers ) {
            if( pro.producer_name == proauth.producer_name ) {
               new_producer_to_last_produced[pro.producer_name] = result.block_num;
            } else {
               auto existing = producer_to_last_produced.find( pro.producer_name );
               if( existing != producer_to_last_produced.end() ) {
                  new_producer_to_last_produced[pro.producer_name] = existing->second;
               } else {
                  new_producer_to_last_produced[pro.producer_name] = result.dpos_irreversible_blocknum;
               }
            }
         }
         new_producer_to_last_produced[proauth.producer_name] = result.block_num;
 
         result.producer_to_last_produced = std::move( new_producer_to_last_produced );
 
         flat_map<account_name,uint32_t> new_producer_to_last_implied_irb;
 
         for( const auto& pro : result.active_schedule.producers ) {
            if( pro.producer_name == proauth.producer_name ) {
               new_producer_to_last_implied_irb[pro.producer_name] = dpos_proposed_irreversible_blocknum;
            } else {
               auto existing = producer_to_last_implied_irb.find( pro.producer_name );
               if( existing != producer_to_last_implied_irb.end() ) {
                  new_producer_to_last_implied_irb[pro.producer_name] = existing->second;
               } else {
                  new_producer_to_last_implied_irb[pro.producer_name] = result.dpos_irreversible_blocknum;
               }
            }
         }
 
         result.producer_to_last_implied_irb = std::move( new_producer_to_last_implied_irb );
 
         result.was_pending_promoted = true;
      } else {
         result.active_schedule                  = active_schedule;
         result.producer_to_last_produced        = producer_to_last_produced;
         result.producer_to_last_produced[proauth.producer_name] = result.block_num;
         result.producer_to_last_implied_irb     = producer_to_last_implied_irb;
         result.producer_to_last_implied_irb[proauth.producer_name] = dpos_proposed_irreversible_blocknum;
      }
 
      return result;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

next() [2/2]

block_header_state sysio::chain::block_header_state::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 ) const

Transitions the current header state into the next header state given the supplied signed block header.

Given a signed block header, generate the expected template based upon the header time, then validate that the provided header matches the template.

If the header specifies new_producers then apply them accordingly.

Definition at line 391 of file block_header_state.cpp.

   {
      return next( h.timestamp, h.confirmed ).finish_next( h, std::move(_additional_signatures), pfs, validator, skip_validate_signee );
   }

Here is the call graph for this function:

prev()

const block_id_type & sysio::chain::block_header_state::prev ( ) const

inline

Definition at line 152 of file block_header_state.hpp.

{ return header.previous; }

sig_digest()

digest_type sysio::chain::block_header_state::sig_digest

(

)

const

Definition at line 403 of file block_header_state.cpp.

                                                     {
      auto header_bmroot = digest_type::hash( std::make_pair( header.digest(), blockroot_merkle.get_root() ) );
      return digest_type::hash( std::make_pair(header_bmroot, pending_schedule.schedule_hash) );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

sign()

void sysio::chain::block_header_state::sign

(

const signer_callback_type &

signer

)

Definition at line 408 of file block_header_state.cpp.

                                                                     {
      auto d = sig_digest();
      auto sigs = signer( d );
 
      SYS_ASSERT(!sigs.empty(), no_block_signatures, "Signer returned no signatures");
      header.producer_signature = sigs.back();
      sigs.pop_back();
 
      additional_signatures = std::move(sigs);
 
      verify_signee();
   }

Here is the call graph for this function:

verify_signee()

void sysio::chain::block_header_state::verify_signee

(

)

const

Definition at line 421 of file block_header_state.cpp.

                                                {
 
      auto num_keys_in_authority = std::visit([](const auto &a){ return a.keys.size(); }, valid_block_signing_authority);
      SYS_ASSERT(1 + additional_signatures.size() <= num_keys_in_authority, wrong_signing_key,
                 "number of block signatures (${num_block_signatures}) exceeds number of keys in block signing authority (${num_keys})",
                 ("num_block_signatures", 1 + additional_signatures.size())
                 ("num_keys", num_keys_in_authority)
                 ("authority", valid_block_signing_authority)
      );
 
      std::set<public_key_type> keys;
      auto digest = sig_digest();
      keys.emplace(fc::crypto::public_key( header.producer_signature, digest, true ));
 
      for (const auto& s: additional_signatures) {
         auto res = keys.emplace(s, digest, true);
         SYS_ASSERT(res.second, wrong_signing_key, "block signed by same key twice", ("key", *res.first));
      }
 
      bool is_satisfied = false;
      size_t relevant_sig_count = 0;
 
      std::tie(is_satisfied, relevant_sig_count) = producer_authority::keys_satisfy_and_relevant(keys, valid_block_signing_authority);
 
      SYS_ASSERT(relevant_sig_count == keys.size(), wrong_signing_key,
                 "block signed by unexpected key",
                 ("signing_keys", keys)("authority", valid_block_signing_authority));
 
      SYS_ASSERT(is_satisfied, wrong_signing_key,
                 "block signatures do not satisfy the block signing authority",
                 ("signing_keys", keys)("authority", valid_block_signing_authority));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

activated_protocol_features

protocol_feature_activation_set_ptr sysio::chain::block_header_state::activated_protocol_features

Definition at line 123 of file block_header_state.hpp.

additional_signatures

vector<signature_type> sysio::chain::block_header_state::additional_signatures

Definition at line 124 of file block_header_state.hpp.

header

signed_block_header sysio::chain::block_header_state::header

Definition at line 121 of file block_header_state.hpp.

header_exts

flat_multimap<uint16_t, block_header_extension> sysio::chain::block_header_state::header_exts

this data is redundant with the data stored in header, but it acts as a cache that avoids duplication of work

Definition at line 128 of file block_header_state.hpp.

id

block_id_type sysio::chain::block_header_state::id

Definition at line 120 of file block_header_state.hpp.

pending_schedule

detail::schedule_info sysio::chain::block_header_state::pending_schedule

Definition at line 122 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