sysio::chain::controller_impl Struct Reference

Collaboration diagram for sysio::chain::controller_impl:

Classes
struct	reset_new_handler

Public Types
typedef pair< scope_name, action_name >	handler_key

Public Member Functions
void	pop_block ()
template<builtin_protocol_feature_t F>
void	on_activation ()
template<builtin_protocol_feature_t F>
void	set_activation_handler ()
void	trigger_activation_handler (builtin_protocol_feature_t f)
void	set_apply_handler (account_name receiver, account_name contract, action_name action, apply_handler v)
	controller_impl (const controller::config &cfg, controller &s, protocol_feature_set &&pfs, const chain_id_type &chain_id)
template<typename Signal , typename Arg >
void	emit (const Signal &s, Arg &&a)
void	dmlog_applied_transaction (const transaction_trace_ptr &t)
void	log_irreversible ()
void	initialize_blockchain_state (const genesis_state &genesis)
void	replay (std::function< bool()> check_shutdown)
void	startup (std::function< void()> shutdown, std::function< bool()> check_shutdown, const snapshot_reader_ptr &snapshot)
void	startup (std::function< void()> shutdown, std::function< bool()> check_shutdown, const genesis_state &genesis)
void	startup (std::function< void()> shutdown, std::function< bool()> check_shutdown)
void	init (std::function< bool()> check_shutdown)
	~controller_impl ()
void	add_indices ()
void	clear_all_undo ()
void	add_contract_tables_to_snapshot (const snapshot_writer_ptr &snapshot) const
void	read_contract_tables_from_snapshot (const snapshot_reader_ptr &snapshot)
void	add_to_snapshot (const snapshot_writer_ptr &snapshot)
void	read_from_snapshot (const snapshot_reader_ptr &snapshot, uint32_t blog_start, uint32_t blog_end)
sha256	calculate_integrity_hash ()
void	create_native_account (const fc::time_point &initial_timestamp, account_name name, const authority &owner, const authority &active, bool is_privileged=false)
void	initialize_database (const genesis_state &genesis)
fc::scoped_exit< std::function< void()> >	make_block_restore_point ()
transaction_trace_ptr	apply_onerror (const generated_transaction &gtrx, fc::time_point block_deadline, fc::microseconds max_transaction_time, fc::time_point start, uint32_t &cpu_time_to_bill_us, uint32_t billed_cpu_time_us, bool explicit_billed_cpu_time=false, bool enforce_whiteblacklist=true)
int64_t	remove_scheduled_transaction (const generated_transaction_object &gto)
bool	failure_is_subjective (const fc::exception &e) const
bool	scheduled_failure_is_subjective (const fc::exception &e) const
transaction_trace_ptr	push_scheduled_transaction (const transaction_id_type &trxid, fc::time_point block_deadline, fc::microseconds max_transaction_time, uint32_t billed_cpu_time_us, bool explicit_billed_cpu_time=false)
transaction_trace_ptr	push_scheduled_transaction (const generated_transaction_object &gto, fc::time_point block_deadline, fc::microseconds max_transaction_time, uint32_t billed_cpu_time_us, bool explicit_billed_cpu_time=false)
template<typename T >
const transaction_receipt &	push_receipt (const T &trx, transaction_receipt_header::status_enum status, uint64_t cpu_usage_us, uint64_t net_usage)
	push_scheduled_transaction
transaction_trace_ptr	push_transaction (const transaction_metadata_ptr &trx, fc::time_point block_deadline, fc::microseconds max_transaction_time, uint32_t billed_cpu_time_us, bool explicit_billed_cpu_time, int64_t subjective_cpu_bill_us)
void	start_block (block_timestamp_type when, uint16_t confirm_block_count, const vector< digest_type > &new_protocol_feature_activations, controller::block_status s, const std::optional< block_id_type > &producer_block_id, const fc::time_point &deadline)
	push_transaction
void	finalize_block ()
	start_block
void	commit_block (bool add_to_fork_db)
	finalize_block
void	check_protocol_features (block_timestamp_type timestamp, const flat_set< digest_type > &currently_activated_protocol_features, const vector< digest_type > &new_protocol_features)
void	report_block_header_diff (const block_header &b, const block_header &ab)
void	apply_block (const block_state_ptr &bsp, controller::block_status s, const trx_meta_cache_lookup &trx_lookup)
block_state_ptr	create_block_state_i (const block_id_type &id, const signed_block_ptr &b, const block_header_state &prev)
	apply_block
std::future< block_state_ptr >	create_block_state_future (const block_id_type &id, const signed_block_ptr &b)
block_state_ptr	create_block_state (const block_id_type &id, const signed_block_ptr &b)
void	push_block (const block_state_ptr &bsp, const forked_branch_callback &forked_branch_cb, const trx_meta_cache_lookup &trx_lookup)
void	replay_push_block (const signed_block_ptr &b, controller::block_status s)
void	maybe_switch_forks (const block_state_ptr &new_head, controller::block_status s, const forked_branch_callback &forked_branch_cb, const trx_meta_cache_lookup &trx_lookup)
vector< transaction_metadata_ptr >	abort_block ()
	push_block
void	update_producers_authority ()
void	create_block_summary (const block_id_type &id)
void	clear_expired_input_transactions (const fc::time_point &deadline)
bool	sender_avoids_whitelist_blacklist_enforcement (account_name sender) const
void	check_actor_list (const flat_set< account_name > &actors) const
void	check_contract_list (account_name code) const
void	check_action_list (account_name code, action_name action) const
void	check_key_list (const public_key_type &key) const
signed_transaction	get_on_block_transaction ()
deep_mind_handler *	get_deep_mind_logger () const
uint32_t	earliest_available_block_num () const

Static Public Member Functions
static auto	validate_db_version (const chainbase::database &db)
static std::optional< genesis_state >	extract_legacy_genesis_state (snapshot_reader &snapshot, uint32_t version)
static checksum256_type	calculate_trx_merkle (const vector< transaction_receipt > &trxs)

Public Attributes
reset_new_handler	rnh
controller &	self
std::function< void()>	shutdown
chainbase::database	db
block_log	blog
std::optional< pending_state >	pending
block_state_ptr	head
fork_database	fork_db
wasm_interface	wasmif
resource_limits_manager	resource_limits
authorization_manager	authorization
protocol_feature_manager	protocol_features
controller::config	conf
const chain_id_type	chain_id
bool	replaying = false
db_read_mode	read_mode = db_read_mode::SPECULATIVE
bool	in_trx_requiring_checks = false
	if true, checks that are normally skipped on replay (e.g. auth checks) cannot be skipped
std::optional< fc::microseconds >	subjective_cpu_leeway
bool	trusted_producer_light_validation = false
uint32_t	snapshot_head_block = 0
named_thread_pool	thread_pool
platform_timer	timer
deep_mind_handler *	deep_mind_logger = nullptr
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

Detailed Description

Definition at line 220 of file controller.cpp.

Member Typedef Documentation

handler_key

pair<scope_name,action_name> sysio::chain::controller_impl::handler_key

Definition at line 255 of file controller.cpp.

Constructor & Destructor Documentation

controller_impl()

sysio::chain::controller_impl::controller_impl ( const controller::config & cfg, controller & s, protocol_feature_set && pfs, const chain_id_type & chain_id )

inline

Definition at line 297 of file controller.cpp.

   :rnh(),
    self(s),
    db( cfg.state_dir,
        cfg.read_only ? database::read_only : database::read_write,
        cfg.state_size, false, cfg.db_map_mode ),
    blog( cfg.blocks_dir, cfg.prune_config ),
    fork_db( cfg.blocks_dir / config::reversible_blocks_dir_name ),
    wasmif( cfg.wasm_runtime, cfg.eosvmoc_tierup, db, cfg.state_dir, cfg.eosvmoc_config, !cfg.profile_accounts.empty() ),
    resource_limits( db, [&s]() { return s.get_deep_mind_logger(); }),
    authorization( s, db ),
    protocol_features( std::move(pfs), [&s]() { return s.get_deep_mind_logger(); } ),
    conf( cfg ),
    chain_id( chain_id ),
    read_mode( cfg.read_mode ),
    thread_pool( "chain", cfg.thread_pool_size )
   {
      fork_db.open( [this]( block_timestamp_type timestamp,
                            const flat_set<digest_type>& cur_features,
                            const vector<digest_type>& new_features )
                           { check_protocol_features( timestamp, cur_features, new_features ); }
      );
 
      set_activation_handler<builtin_protocol_feature_t::preactivate_feature>();
      set_activation_handler<builtin_protocol_feature_t::replace_deferred>();
      set_activation_handler<builtin_protocol_feature_t::get_sender>();
      set_activation_handler<builtin_protocol_feature_t::webauthn_key>();
      set_activation_handler<builtin_protocol_feature_t::wtmsig_block_signatures>();
      set_activation_handler<builtin_protocol_feature_t::action_return_value>();
      set_activation_handler<builtin_protocol_feature_t::configurable_wasm_limits>();
      set_activation_handler<builtin_protocol_feature_t::blockchain_parameters>();
      set_activation_handler<builtin_protocol_feature_t::get_code_hash>();
      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::em_key>();
 
      self.irreversible_block.connect([this](const block_state_ptr& bsp) {
         wasmif.current_lib(bsp->block_num);
      });
 
 
#define SET_APP_HANDLER( receiver, contract, action) \
   set_apply_handler( account_name(#receiver), account_name(#contract), action_name(#action), \
                      &BOOST_PP_CAT(apply_, BOOST_PP_CAT(contract, BOOST_PP_CAT(_,action) ) ) )
 
   SET_APP_HANDLER( sysio, sysio, newaccount );
   SET_APP_HANDLER( sysio, sysio, setcode );
   SET_APP_HANDLER( sysio, sysio, setabi );
   SET_APP_HANDLER( sysio, sysio, updateauth );
   SET_APP_HANDLER( sysio, sysio, deleteauth );
   SET_APP_HANDLER( sysio, sysio, linkauth );
   SET_APP_HANDLER( sysio, sysio, unlinkauth );
/*
   SET_APP_HANDLER( sysio, sysio, postrecovery );
   SET_APP_HANDLER( sysio, sysio, passrecovery );
   SET_APP_HANDLER( sysio, sysio, vetorecovery );
*/
 
   SET_APP_HANDLER( sysio, sysio, canceldelay );
   }

~controller_impl()

sysio::chain::controller_impl::~controller_impl ( )

inline

Definition at line 724 of file controller.cpp.

                      {
      thread_pool.stop();
      pending.reset();
   }

Here is the call graph for this function:

Member Function Documentation

abort_block()

vector< transaction_metadata_ptr > sysio::chain::controller_impl::abort_block ( )

inline

Definition at line 2315 of file controller.cpp.

                                                  {
      vector<transaction_metadata_ptr> applied_trxs;
      if( pending ) {
         applied_trxs = pending->extract_trx_metas();
         pending.reset();
         protocol_features.popped_blocks_to( head->block_num );
      }
      return applied_trxs;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

add_contract_tables_to_snapshot()

void sysio::chain::controller_impl::add_contract_tables_to_snapshot ( const snapshot_writer_ptr & snapshot ) const

inline

Definition at line 747 of file controller.cpp.

                                                                                     {
      snapshot->write_section("contract_tables", [this]( auto& section ) {
         index_utils<table_id_multi_index>::walk(db, [this, &section]( const table_id_object& table_row ){
            // add a row for the table
            section.add_row(table_row, db);
 
            // followed by a size row and then N data rows for each type of table
            contract_database_index_set::walk_indices([this, &section, &table_row]( auto utils ) {
               using utils_t = decltype(utils);
               using value_t = typename decltype(utils)::index_t::value_type;
               using by_table_id = object_to_table_id_tag_t<value_t>;
 
               auto tid_key = boost::make_tuple(table_row.id);
               auto next_tid_key = boost::make_tuple(table_id_object::id_type(table_row.id._id + 1));
 
               unsigned_int size = utils_t::template size_range<by_table_id>(db, tid_key, next_tid_key);
               section.add_row(size, db);
 
               utils_t::template walk_range<by_table_id>(db, tid_key, next_tid_key, [this, &section]( const auto &row ) {
                  section.add_row(row, db);
               });
            });
         });
      });
   }

Here is the call graph for this function:

Here is the caller graph for this function:

add_indices()

void sysio::chain::controller_impl::add_indices ( )

inline

Definition at line 729 of file controller.cpp.

                      {
      controller_index_set::add_indices(db);
      contract_database_index_set::add_indices(db);
 
      authorization.add_indices();
      resource_limits.add_indices();
   }

Here is the call graph for this function:

add_to_snapshot()

void sysio::chain::controller_impl::add_to_snapshot ( const snapshot_writer_ptr & snapshot )

inline

Definition at line 802 of file controller.cpp.

                                                               {
      // clear in case the previous call to clear did not finish in time of deadline
      clear_expired_input_transactions( fc::time_point::maximum() );
 
      snapshot->write_section<chain_snapshot_header>([this]( auto &section ){
         section.add_row(chain_snapshot_header(), db);
      });
 
      snapshot->write_section<block_state>([this]( auto &section ){
         section.template add_row<block_header_state>(*head, db);
      });
 
      controller_index_set::walk_indices([this, &snapshot]( auto utils ){
         using value_t = typename decltype(utils)::index_t::value_type;
 
         // skip the table_id_object as its inlined with contract tables section
         if (std::is_same<value_t, table_id_object>::value) {
            return;
         }
 
         // skip the database_header as it is only relevant to in-memory database
         if (std::is_same<value_t, database_header_object>::value) {
            return;
         }
 
         snapshot->write_section<value_t>([this]( auto& section ){
            decltype(utils)::walk(db, [this, &section]( const auto &row ) {
               section.add_row(row, db);
            });
         });
      });
 
      add_contract_tables_to_snapshot(snapshot);
 
      authorization.add_to_snapshot(snapshot);
      resource_limits.add_to_snapshot(snapshot);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

apply_block()

void sysio::chain::controller_impl::apply_block ( const block_state_ptr & bsp, controller::block_status s, const trx_meta_cache_lookup & trx_lookup )

inline

Definition at line 1948 of file controller.cpp.

   { try {
      try {
         const signed_block_ptr& b = bsp->block;
         const auto& new_protocol_feature_activations = bsp->get_new_protocol_feature_activations();
 
         auto producer_block_id = bsp->id;
         start_block( b->timestamp, b->confirmed, new_protocol_feature_activations, s, producer_block_id, fc::time_point::maximum() );
 
         const bool existing_trxs_metas = !bsp->trxs_metas().empty();
         const bool pub_keys_recovered = bsp->is_pub_keys_recovered();
         const bool skip_auth_checks = self.skip_auth_check();
         std::vector<std::tuple<transaction_metadata_ptr, recover_keys_future>> trx_metas;
         bool use_bsp_cached = false;
         if( pub_keys_recovered || (skip_auth_checks && existing_trxs_metas) ) {
            use_bsp_cached = true;
         } else {
            trx_metas.reserve( b->transactions.size() );
            for( const auto& receipt : b->transactions ) {
               if( std::holds_alternative<packed_transaction>(receipt.trx)) {
                  const auto& pt = std::get<packed_transaction>(receipt.trx);
                  transaction_metadata_ptr trx_meta_ptr = trx_lookup ? trx_lookup( pt.id() ) : transaction_metadata_ptr{};
                  if( trx_meta_ptr && *trx_meta_ptr->packed_trx() != pt ) trx_meta_ptr = nullptr;
                  if( trx_meta_ptr && ( skip_auth_checks || !trx_meta_ptr->recovered_keys().empty() ) ) {
                     trx_metas.emplace_back( std::move( trx_meta_ptr ), recover_keys_future{} );
                  } else if( skip_auth_checks ) {
                     packed_transaction_ptr ptrx( b, &pt ); // alias signed_block_ptr
                     trx_metas.emplace_back(
                           transaction_metadata::create_no_recover_keys( std::move(ptrx), transaction_metadata::trx_type::input ),
                           recover_keys_future{} );
                  } else {
                     packed_transaction_ptr ptrx( b, &pt ); // alias signed_block_ptr
                     auto fut = transaction_metadata::start_recover_keys(
                           std::move( ptrx ), thread_pool.get_executor(), chain_id, microseconds::maximum(), transaction_metadata::trx_type::input  );
                     trx_metas.emplace_back( transaction_metadata_ptr{}, std::move( fut ) );
                  }
               }
            }
         }
 
         transaction_trace_ptr trace;
 
         size_t packed_idx = 0;
         for( const auto& receipt : b->transactions ) {
            const auto& trx_receipts = std::get<building_block>(pending->_block_stage)._pending_trx_receipts;
            auto num_pending_receipts = trx_receipts.size();
            if( std::holds_alternative<packed_transaction>(receipt.trx) ) {
               const auto& trx_meta = ( use_bsp_cached ? bsp->trxs_metas().at( packed_idx )
                                                       : ( !!std::get<0>( trx_metas.at( packed_idx ) ) ?
                                                             std::get<0>( trx_metas.at( packed_idx ) )
                                                             : std::get<1>( trx_metas.at( packed_idx ) ).get() ) );
               trace = push_transaction( trx_meta, fc::time_point::maximum(), fc::microseconds::maximum(), receipt.cpu_usage_us, true, 0 );
               ++packed_idx;
            } else if( std::holds_alternative<transaction_id_type>(receipt.trx) ) {
               trace = push_scheduled_transaction( std::get<transaction_id_type>(receipt.trx), fc::time_point::maximum(), fc::microseconds::maximum(), receipt.cpu_usage_us, true );
            } else {
               SYS_ASSERT( false, block_validate_exception, "encountered unexpected receipt type" );
            }
 
            bool transaction_failed =  trace && trace->except;
            bool transaction_can_fail = receipt.status == transaction_receipt_header::hard_fail && std::holds_alternative<transaction_id_type>(receipt.trx);
            if( transaction_failed && !transaction_can_fail) {
               edump((*trace));
               throw *trace->except;
            }
 
            SYS_ASSERT( trx_receipts.size() > 0,
                        block_validate_exception, "expected a receipt, block_num ${bn}, block_id ${id}, receipt ${e}",
                        ("bn", b->block_num())("id", producer_block_id)("e", receipt)
                      );
            SYS_ASSERT( trx_receipts.size() == num_pending_receipts + 1,
                        block_validate_exception, "expected receipt was not added, block_num ${bn}, block_id ${id}, receipt ${e}",
                        ("bn", b->block_num())("id", producer_block_id)("e", receipt)
                      );
            const transaction_receipt_header& r = trx_receipts.back();
            SYS_ASSERT( r == static_cast<const transaction_receipt_header&>(receipt),
                        block_validate_exception, "receipt does not match, ${lhs} != ${rhs}",
                        ("lhs", r)("rhs", static_cast<const transaction_receipt_header&>(receipt)) );
         }
 
         // validated in create_block_state_future()
         std::get<building_block>(pending->_block_stage)._transaction_mroot = b->transaction_mroot;
 
         // New: Process the s_header from block header extensions
         auto s_header_it = std::find_if(b->header_extensions.begin(), b->header_extensions.end(),
                                       [](const auto& ext) { return ext.first == s_root_extension::extension_id(); });
         if (s_header_it != b->header_extensions.end()) {
            ilog("Found s_root_extension in header_extensions, attempting to extract...");
            s_header extracted_s_header = fc::raw::unpack<s_header>(s_header_it->second);
            ilog("Extracted s_header: ${s_header}", ("s_header", extracted_s_header.to_string()));
            self.set_s_header(extracted_s_header); // Attempt to set s-header
         }
 
         finalize_block();
 
         auto& ab = std::get<assembled_block>(pending->_block_stage);
 
         
 
         if( producer_block_id != ab._id ) {
            elog( "Validation block id does not match producer block id" );
            report_block_header_diff( *b, *ab._unsigned_block );
            // this implicitly asserts that all header fields (less the signature) are identical
            SYS_ASSERT( producer_block_id == ab._id, block_validate_exception, "Block ID does not match",
                        ("producer_block_id", producer_block_id)("validator_block_id", ab._id) );
         }
 
         if( !use_bsp_cached ) {
            bsp->set_trxs_metas( std::move( ab._trx_metas ), !skip_auth_checks );
         }
         // create completed_block with the existing block_state as we just verified it is the same as assembled_block
         pending->_block_stage = completed_block{ bsp };
 
         commit_block(false);
         return;
      } catch ( const std::bad_alloc& ) {
         throw;
      } catch ( const boost::interprocess::bad_alloc& ) {
         throw;
      } catch ( const fc::exception& e ) {
         edump((e.to_detail_string()));
         abort_block();
         throw;
      } catch ( const std::exception& e ) {
         edump((e.what()));
         abort_block();
         throw;
      }
   } FC_CAPTURE_AND_RETHROW() } 

Here is the call graph for this function:

Here is the caller graph for this function:

apply_onerror()

transaction_trace_ptr sysio::chain::controller_impl::apply_onerror ( const generated_transaction & gtrx, fc::time_point block_deadline, fc::microseconds max_transaction_time, fc::time_point start, uint32_t & cpu_time_to_bill_us, uint32_t billed_cpu_time_us, bool explicit_billed_cpu_time = false, bool enforce_whiteblacklist = true )

inline

Definition at line 1102 of file controller.cpp.

   {
      signed_transaction etrx;
      // Deliver onerror action containing the failed deferred transaction directly back to the sender.
      etrx.actions.emplace_back( vector<permission_level>{{gtrx.sender, config::active_name}},
                                 onerror( gtrx.sender_id, gtrx.packed_trx.data(), gtrx.packed_trx.size() ) );
      if( self.is_builtin_activated( builtin_protocol_feature_t::no_duplicate_deferred_id ) ) {
         etrx.expiration = time_point_sec();
         etrx.ref_block_num = 0;
         etrx.ref_block_prefix = 0;
      } else {
         etrx.expiration = self.pending_block_time() + fc::microseconds(999'999); // Round up to nearest second to avoid appearing expired
         etrx.set_reference_block( self.head_block_id() );
      }
 
      if (auto dm_logger = get_deep_mind_logger()) {
         dm_logger->on_onerror(etrx);
      }
 
      transaction_checktime_timer trx_timer(timer);
      const packed_transaction trx( std::move( etrx ) );
      transaction_context trx_context( self, trx, std::move(trx_timer), start );
 
      trx_context.block_deadline = block_deadline;
      trx_context.max_transaction_time_subjective = max_transaction_time;
      trx_context.explicit_billed_cpu_time = explicit_billed_cpu_time;
      trx_context.billed_cpu_time_us = billed_cpu_time_us;
      trx_context.enforce_whiteblacklist = enforce_whiteblacklist;
      transaction_trace_ptr trace = trx_context.trace;
 
      auto handle_exception = [&](const auto& e)
      {
         cpu_time_to_bill_us = trx_context.update_billed_cpu_time( fc::time_point::now() );
         trace->error_code = controller::convert_exception_to_error_code( e );
         trace->except = e;
         trace->except_ptr = std::current_exception();
      };
 
      try {
         trx_context.init_for_implicit_trx();
         trx_context.published = gtrx.published;
         trx_context.execute_action( trx_context.schedule_action( trx.get_transaction().actions.back(), gtrx.sender, false, 0, 0 ), 0 );
         trx_context.finalize(); // Automatically rounds up network and CPU usage in trace and bills payers if successful
 
         auto restore = make_block_restore_point();
         trace->receipt = push_receipt( gtrx.trx_id, transaction_receipt::soft_fail,
                                        trx_context.billed_cpu_time_us, trace->net_usage );
         fc::move_append( std::get<building_block>(pending->_block_stage)._action_receipt_digests,
                          std::move(trx_context.executed_action_receipt_digests) );
 
         trx_context.squash();
         restore.cancel();
         return trace;
      } catch( const disallowed_transaction_extensions_bad_block_exception& ) {
         throw;
      } catch( const protocol_feature_bad_block_exception& ) {
         throw;
      } catch ( const std::bad_alloc& ) {
         throw;
      } catch ( const boost::interprocess::bad_alloc& ) {
         throw;
      } catch( const fc::exception& e ) {
         handle_exception(e);
      } catch ( const std::exception& e ) {
         auto wrapper = fc::std_exception_wrapper::from_current_exception(e);
         handle_exception(wrapper);
      }
      return trace;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_integrity_hash()

sha256 sysio::chain::controller_impl::calculate_integrity_hash ( )

inline

Definition at line 978 of file controller.cpp.

                                     {
      sha256::encoder enc;
      auto hash_writer = std::make_shared<integrity_hash_snapshot_writer>(enc);
      add_to_snapshot(hash_writer);
      hash_writer->finalize();
 
      return enc.result();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_trx_merkle()

static checksum256_type sysio::chain::controller_impl::calculate_trx_merkle ( const vector< transaction_receipt > & trxs )

inlinestatic

Definition at line 2325 of file controller.cpp.

                                                                                           {
      vector<digest_type> trx_digests;
      trx_digests.reserve( trxs.size() );
      for( const auto& a : trxs )
         trx_digests.emplace_back( a.digest() );
 
      return merkle( move(trx_digests) );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

check_action_list()

void sysio::chain::controller_impl::check_action_list ( account_name code, action_name action ) const

inline

Definition at line 2506 of file controller.cpp.

                                                                        {
      if( conf.action_blacklist.size() > 0 ) {
         SYS_ASSERT( conf.action_blacklist.find( std::make_pair(code, action) ) == conf.action_blacklist.end(),
                     action_blacklist_exception,
                     "action '${code}::${action}' is on the action blacklist",
                     ("code", code)("action", action)
                   );
      }
   }

check_actor_list()

void sysio::chain::controller_impl::check_actor_list ( const flat_set< account_name > & actors ) const

inline

Definition at line 2407 of file controller.cpp.

                                                                      {
      if( actors.size() == 0 ) return;
 
      if( conf.actor_whitelist.size() > 0 ) {
         // throw if actors is not a subset of whitelist
         const auto& whitelist = conf.actor_whitelist;
         bool is_subset = true;
 
         // quick extents check, then brute force the check actors
         if (*actors.cbegin() >= *whitelist.cbegin() && *actors.crbegin() <= *whitelist.crbegin() ) {
            auto lower_bound = whitelist.cbegin();
            for (const auto& actor: actors) {
               lower_bound = std::lower_bound(lower_bound, whitelist.cend(), actor);
 
               // if the actor is not found, this is not a subset
               if (lower_bound == whitelist.cend() || *lower_bound != actor ) {
                  is_subset = false;
                  break;
               }
 
               // if the actor was found, we are guaranteed that other actors are either not present in the whitelist
               // or will be present in the range defined as [next actor,end)
               lower_bound = std::next(lower_bound);
            }
         } else {
            is_subset = false;
         }
 
         // helper lambda to lazily calculate the actors for error messaging
         static auto generate_missing_actors = [](const flat_set<account_name>& actors, const flat_set<account_name>& whitelist) -> vector<account_name> {
            vector<account_name> excluded;
            excluded.reserve( actors.size() );
            set_difference( actors.begin(), actors.end(),
                            whitelist.begin(), whitelist.end(),
                            std::back_inserter(excluded) );
            return excluded;
         };
 
         SYS_ASSERT( is_subset,  actor_whitelist_exception,
                     "authorizing actor(s) in transaction are not on the actor whitelist: ${actors}",
                     ("actors", generate_missing_actors(actors, whitelist))
                   );
      } else if( conf.actor_blacklist.size() > 0 ) {
         // throw if actors intersects blacklist
         const auto& blacklist = conf.actor_blacklist;
         bool intersects = false;
 
         // quick extents check then brute force check actors
         if( *actors.cbegin() <= *blacklist.crbegin() && *actors.crbegin() >= *blacklist.cbegin() ) {
            auto lower_bound = blacklist.cbegin();
            for (const auto& actor: actors) {
               lower_bound = std::lower_bound(lower_bound, blacklist.cend(), actor);
 
               // if the lower bound in the blacklist is at the end, all other actors are guaranteed to
               // not exist in the blacklist
               if (lower_bound == blacklist.cend()) {
                  break;
               }
 
               // if the lower bound of an actor IS the actor, then we have an intersection
               if (*lower_bound == actor) {
                  intersects = true;
                  break;
               }
            }
         }
 
         // helper lambda to lazily calculate the actors for error messaging
         static auto generate_blacklisted_actors = [](const flat_set<account_name>& actors, const flat_set<account_name>& blacklist) -> vector<account_name> {
            vector<account_name> blacklisted;
            blacklisted.reserve( actors.size() );
            set_intersection( actors.begin(), actors.end(),
                              blacklist.begin(), blacklist.end(),
                              std::back_inserter(blacklisted)
                            );
            return blacklisted;
         };
 
         SYS_ASSERT( !intersects, actor_blacklist_exception,
                     "authorizing actor(s) in transaction are on the actor blacklist: ${actors}",
                     ("actors", generate_blacklisted_actors(actors, blacklist))
                   );
      }
   }

Here is the caller graph for this function:

check_contract_list()

void sysio::chain::controller_impl::check_contract_list ( account_name code ) const

inline

Definition at line 2492 of file controller.cpp.

                                                      {
      if( conf.contract_whitelist.size() > 0 ) {
         SYS_ASSERT( conf.contract_whitelist.find( code ) != conf.contract_whitelist.end(),
                     contract_whitelist_exception,
                     "account '${code}' is not on the contract whitelist", ("code", code)
                   );
      } else if( conf.contract_blacklist.size() > 0 ) {
         SYS_ASSERT( conf.contract_blacklist.find( code ) == conf.contract_blacklist.end(),
                     contract_blacklist_exception,
                     "account '${code}' is on the contract blacklist", ("code", code)
                   );
      }
   }

check_key_list()

void sysio::chain::controller_impl::check_key_list ( const public_key_type & key ) const

inline

Definition at line 2516 of file controller.cpp.

                                                          {
      if( conf.key_blacklist.size() > 0 ) {
         SYS_ASSERT( conf.key_blacklist.find( key ) == conf.key_blacklist.end(),
                     key_blacklist_exception,
                     "public key '${key}' is on the key blacklist",
                     ("key", key)
                   );
      }
   }

check_protocol_features()

void sysio::chain::controller_impl::check_protocol_features ( block_timestamp_type timestamp, const flat_set< digest_type > & currently_activated_protocol_features, const vector< digest_type > & new_protocol_features )

inline

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 after controller_impl construction.

This should not be an issue since the purpose of this function is to ensure all of the protocol features in the supplied vector are recognized by the software, and the set of recognized protocol features is determined at startup and cannot be changed without a restart.

Definition at line 1875 of file controller.cpp.

   {
      const auto& pfs = protocol_features.get_protocol_feature_set();
 
      for( auto itr = new_protocol_features.begin(); itr != new_protocol_features.end(); ++itr ) {
         const auto& f = *itr;
 
         auto status = pfs.is_recognized( f, timestamp );
         switch( status ) {
            case protocol_feature_set::recognized_t::unrecognized:
               SYS_THROW( protocol_feature_exception,
                          "protocol feature with digest '${digest}' is unrecognized", ("digest", f) );
            break;
            case protocol_feature_set::recognized_t::disabled:
               SYS_THROW( protocol_feature_exception,
                          "protocol feature with digest '${digest}' is disabled", ("digest", f) );
            break;
            case protocol_feature_set::recognized_t::too_early:
               SYS_THROW( protocol_feature_exception,
                          "${timestamp} is too early for the earliest allowed activation time of the protocol feature with digest '${digest}'", ("digest", f)("timestamp", timestamp) );
            break;
            case protocol_feature_set::recognized_t::ready:
            break;
            default:
               SYS_THROW( protocol_feature_exception, "unexpected recognized_t status" );
            break;
         }
 
         SYS_ASSERT( currently_activated_protocol_features.find( f ) == currently_activated_protocol_features.end(),
                     protocol_feature_exception,
                     "protocol feature with digest '${digest}' has already been activated",
                     ("digest", f)
         );
 
         auto dependency_checker = [&currently_activated_protocol_features, &new_protocol_features, &itr]
                                   ( const digest_type& f ) -> bool
         {
            if( currently_activated_protocol_features.find( f ) != currently_activated_protocol_features.end() )
               return true;
 
            return (std::find( new_protocol_features.begin(), itr, f ) != itr);
         };
 
         SYS_ASSERT( pfs.validate_dependencies( f, dependency_checker ), protocol_feature_exception,
                     "not all dependencies of protocol feature with digest '${digest}' have been activated",
                     ("digest", f)
         );
      }
   }

Here is the call graph for this function:

clear_all_undo()

void sysio::chain::controller_impl::clear_all_undo ( )

inline

Definition at line 737 of file controller.cpp.

                         {
      // Rewind the database to the last irreversible block
      db.undo_all();
      /*
      FC_ASSERT(db.revision() == self.head_block_num(),
                  "Chainbase revision does not match head block num",
                  ("rev", db.revision())("head_block", self.head_block_num()));
                  */
   }

Here is the call graph for this function:

clear_expired_input_transactions()

void sysio::chain::controller_impl::clear_expired_input_transactions ( const fc::time_point & deadline )

inline

Definition at line 2379 of file controller.cpp.

                                                                       {
      //Look for expired transactions in the deduplication list, and remove them.
      auto& transaction_idx = db.get_mutable_index<transaction_multi_index>();
      const auto& dedupe_index = transaction_idx.indices().get<by_expiration>();
      auto now = self.is_building_block() ? self.pending_block_time() : self.head_block_time();
      const auto total = dedupe_index.size();
      uint32_t num_removed = 0;
      while( (!dedupe_index.empty()) && ( now > fc::time_point(dedupe_index.begin()->expiration) ) ) {
         transaction_idx.remove(*dedupe_index.begin());
         ++num_removed;
         if( deadline <= fc::time_point::now() ) {
            break;
         }
      }
      dlog("removed ${n} expired transactions of the ${t} input dedup list, pending block time ${pt}",
           ("n", num_removed)("t", total)("pt", now));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

commit_block()

void sysio::chain::controller_impl::commit_block ( bool add_to_fork_db )

inline

Postcondition

regardless of the success of commit block there is no active pending block

Definition at line 1827 of file controller.cpp.

                                            {
      auto reset_pending_on_exit = fc::make_scoped_exit([this]{
         pending.reset();
      });
 
      try {
         SYS_ASSERT( std::holds_alternative<completed_block>(pending->_block_stage), block_validate_exception,
                     "cannot call commit_block until pending block is completed" );
 
         auto bsp = std::get<completed_block>(pending->_block_stage)._block_state;
 
         if( add_to_fork_db ) {
            fork_db.add( bsp );
            fork_db.mark_valid( bsp );
            emit( self.accepted_block_header, bsp );
            head = fork_db.head();
            SYS_ASSERT( bsp == head, fork_database_exception, "committed block did not become the new head in fork database");
         }
 
         if (auto dm_logger = get_deep_mind_logger()) {
            dm_logger->on_accepted_block(bsp);
         }
 
         emit( self.accepted_block, bsp );
 
         if( add_to_fork_db ) {
            log_irreversible();
         }
      } catch (...) {
         // dont bother resetting pending, instead abort the block
         reset_pending_on_exit.cancel();
         abort_block();
         throw;
      }
 
      // push the state for pending.
      pending->push();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

create_block_state()

block_state_ptr sysio::chain::controller_impl::create_block_state ( const block_id_type & id, const signed_block_ptr & b )

inline

Definition at line 2119 of file controller.cpp.

                                                                                            {
      SYS_ASSERT( b, block_validate_exception, "null block" );
 
      // no reason for a block_state if fork_db already knows about block
      auto existing = fork_db.get_block( id );
      SYS_ASSERT( !existing, fork_database_exception, "we already know about this block: ${id}", ("id", id) );
 
      // previous not found could mean that previous block not applied yet
      auto prev = fork_db.get_block_header( b->previous );
      if( !prev ) return {};
 
      return create_block_state_i( id, b, *prev );
   }

Here is the call graph for this function:

create_block_state_future()

std::future< block_state_ptr > sysio::chain::controller_impl::create_block_state_future ( const block_id_type & id, const signed_block_ptr & b )

inline

Definition at line 2102 of file controller.cpp.

                                                                                                              {
      SYS_ASSERT( b, block_validate_exception, "null block" );
 
      return async_thread_pool( thread_pool.get_executor(), [b, id, control=this]() {
         // no reason for a block_state if fork_db already knows about block
         auto existing = control->fork_db.get_block( id );
         SYS_ASSERT( !existing, fork_database_exception, "we already know about this block: ${id}", ("id", id) );
 
         auto prev = control->fork_db.get_block_header( b->previous );
         SYS_ASSERT( prev, unlinkable_block_exception,
                     "unlinkable block ${id}", ("id", id)("previous", b->previous) );
 
         return control->create_block_state_i( id, b, *prev );
      } );
   }

Here is the call graph for this function:

create_block_state_i()

block_state_ptr sysio::chain::controller_impl::create_block_state_i ( const block_id_type & id, const signed_block_ptr & b, const block_header_state & prev )

inline

Definition at line 2080 of file controller.cpp.

                                                                                                                              {
      auto trx_mroot = calculate_trx_merkle( b->transactions );
      SYS_ASSERT( b->transaction_mroot == trx_mroot, block_validate_exception,
                  "invalid block transaction merkle root ${b} != ${c}", ("b", b->transaction_mroot)("c", trx_mroot) );
 
      const bool skip_validate_signee = false;
      auto bsp = std::make_shared<block_state>(
            prev,
            b,
            protocol_features.get_protocol_feature_set(),
            [this]( block_timestamp_type timestamp,
                    const flat_set<digest_type>& cur_features,
                    const vector<digest_type>& new_features )
            { check_protocol_features( timestamp, cur_features, new_features ); },
            skip_validate_signee
      );
 
      SYS_ASSERT( id == bsp->id, block_validate_exception,
                  "provided id ${id} does not match block id ${bid}", ("id", id)("bid", bsp->id) );
      return bsp;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

create_block_summary()

void sysio::chain::controller_impl::create_block_summary ( const block_id_type & id )

inline

Definition at line 2370 of file controller.cpp.

                                                      {
      auto block_num = block_header::num_from_id(id);
      auto sid = block_num & 0xffff;
      db.modify( db.get<block_summary_object,by_id>(sid), [&](block_summary_object& bso ) {
          bso.block_id = id;
      });
   }

Here is the call graph for this function:

Here is the caller graph for this function:

create_native_account()

void sysio::chain::controller_impl::create_native_account ( const fc::time_point & initial_timestamp, account_name name, const authority & owner, const authority & active, bool is_privileged = false )

inline

Definition at line 987 of file controller.cpp.

                                                                                                                                                                       {
      db.create<account_object>([&](auto& a) {
         a.name = name;
         a.creation_date = initial_timestamp;
 
         if( name == config::system_account_name ) {
            // The initial sysio ABI value affects consensus; see  https://github.com/SYSIO/eos/issues/7794
            // TODO: This doesn't charge RAM; a fix requires a consensus upgrade.
            a.abi.assign(sysio_abi_bin, sizeof(sysio_abi_bin));
         }
      });
      db.create<account_metadata_object>([&](auto & a) {
         a.name = name;
         a.set_privileged( is_privileged );
      });
 
      const auto& owner_permission  = authorization.create_permission(name, config::owner_name, 0,
                                                                      owner, initial_timestamp );
      const auto& active_permission = authorization.create_permission(name, config::active_name, owner_permission.id,
                                                                      active, initial_timestamp );
 
      resource_limits.initialize_account(name);
 
      int64_t ram_delta = config::overhead_per_account_ram_bytes;
      ram_delta += 2*config::billable_size_v<permission_object>;
      ram_delta += owner_permission.auth.get_billable_size();
      ram_delta += active_permission.auth.get_billable_size();
 
      if (auto dm_logger = get_deep_mind_logger()) {
         dm_logger->on_ram_trace(RAM_EVENT_ID("${name}", ("name", name)), "account", "add", "newaccount");
      }
 
      resource_limits.add_pending_ram_usage(name, ram_delta);
      resource_limits.verify_account_ram_usage(name);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

dmlog_applied_transaction()

void sysio::chain::controller_impl::dmlog_applied_transaction ( const transaction_trace_ptr & t )

inline

Definition at line 389 of file controller.cpp.

                                                                  {
      if (auto dm_logger = get_deep_mind_logger()) {
         dm_logger->on_applied_transaction(self.head_block_num() + 1, t);
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

earliest_available_block_num()

uint32_t sysio::chain::controller_impl::earliest_available_block_num ( ) const

inline

Definition at line 2576 of file controller.cpp.

                                                 {
      return (blog.first_block_num() != 0) ? blog.first_block_num() : fork_db.root()->block_num;
   }

Here is the call graph for this function:

emit()

template<typename Signal , typename Arg >

void sysio::chain::controller_impl::emit ( const Signal & s, Arg && a )

inline

Plugins / observers listening to signals emited (such as accepted_transaction) might trigger errors and throw exceptions. Unless those exceptions are caught it could impact consensus and/or cause a node to fork.

If it is ever desirable to let a signal handler bubble an exception out of this method a full audit of its uses needs to be undertaken.

Definition at line 368 of file controller.cpp.

                                         {
      try {
         s( std::forward<Arg>( a ));
      } catch (std::bad_alloc& e) {
         wlog( "std::bad_alloc: ${w}", ("w", e.what()) );
         throw e;
      } catch (boost::interprocess::bad_alloc& e) {
         wlog( "boost::interprocess::bad alloc: ${w}", ("w", e.what()) );
         throw e;
      } catch ( controller_emit_signal_exception& e ) {
         wlog( "controller_emit_signal_exception: ${details}", ("details", e.to_detail_string()) );
         throw e;
      } catch ( fc::exception& e ) {
         wlog( "fc::exception: ${details}", ("details", e.to_detail_string()) );
      } catch ( std::exception& e ) {
         wlog( "std::exception: ${details}", ("details", e.what()) );
      } catch ( ... ) {
         wlog( "signal handler threw exception" );
      }
   }

Here is the caller graph for this function:

extract_legacy_genesis_state()

static std::optional< genesis_state > sysio::chain::controller_impl::extract_legacy_genesis_state ( snapshot_reader & snapshot, uint32_t version )

inlinestatic

Definition at line 840 of file controller.cpp.

                                                                                                                 {
      std::optional<genesis_state> genesis;
      using v2 = legacy::snapshot_global_property_object_v2;
 
      if (std::clamp(version, v2::minimum_version, v2::maximum_version) == version ) {
         genesis.emplace();
         snapshot.read_section<genesis_state>([&genesis=*genesis]( auto &section ){
            section.read_row(genesis);
         });
      }
      return genesis;
   }

Here is the caller graph for this function:

failure_is_subjective()

bool sysio::chain::controller_impl::failure_is_subjective ( const fc::exception & e ) const

inline

Definition at line 1193 of file controller.cpp.

                                                            {
      auto code = e.code();
      return    (code == subjective_block_production_exception::code_value)
             || (code == block_net_usage_exceeded::code_value)
             || (code == greylist_net_usage_exceeded::code_value)
             || (code == block_cpu_usage_exceeded::code_value)
             || (code == greylist_cpu_usage_exceeded::code_value)
             || (code == deadline_exception::code_value)
             || (code == leeway_deadline_exception::code_value)
             || (code == actor_whitelist_exception::code_value)
             || (code == actor_blacklist_exception::code_value)
             || (code == contract_whitelist_exception::code_value)
             || (code == contract_blacklist_exception::code_value)
             || (code == action_blacklist_exception::code_value)
             || (code == key_blacklist_exception::code_value)
             || (code == sig_variable_size_limit_exception::code_value)
             || (code == inline_action_too_big_nonprivileged::code_value);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

finalize_block()

void sysio::chain::controller_impl::finalize_block ( )

inline

Definition at line 1759 of file controller.cpp.

   {
      SYS_ASSERT( pending, block_validate_exception, "it is not valid to finalize when there is no pending block");
      SYS_ASSERT( std::holds_alternative<building_block>(pending->_block_stage), block_validate_exception, "already called finalize_block");
 
      try {
 
      auto& pbhs = pending->get_pending_block_header_state();
 
      // Update resource limits:
      resource_limits.process_account_limit_updates();
      const auto& chain_config = self.get_global_properties().configuration;
      uint64_t CPU_TARGET = SYS_PERCENT(chain_config.max_block_cpu_usage, chain_config.target_block_cpu_usage_pct);
      resource_limits.set_block_parameters(
         { CPU_TARGET, chain_config.max_block_cpu_usage, config::block_cpu_usage_average_window_ms / config::block_interval_ms, config::maximum_elastic_resource_multiplier, {99, 100}, {1000, 999}},
         {SYS_PERCENT(chain_config.max_block_net_usage, chain_config.target_block_net_usage_pct), chain_config.max_block_net_usage, config::block_size_average_window_ms / config::block_interval_ms, config::maximum_elastic_resource_multiplier, {99, 100}, {1000, 999}}
      );
      resource_limits.process_block_usage(pbhs.block_num);
 
      auto& bb = std::get<building_block>(pending->_block_stage);
 
      if (bb._s_header){
         ilog("s_header present in finalize block, adding to block header: ${s}", ("s", bb._s_header->to_string()));
      }
 
      // Create (unsigned) block:
      auto block_ptr = std::make_shared<signed_block>( pbhs.make_block_header(
         bb._transaction_mroot ? *bb._transaction_mroot : calculate_trx_merkle( bb._pending_trx_receipts ),
         merkle( std::move( std::get<building_block>(pending->_block_stage)._action_receipt_digests ) ),
         bb._new_pending_producer_schedule,
         std::move( bb._new_protocol_feature_activations ),
         protocol_features.get_protocol_feature_set(),
         bb._s_header // Include optional s_header in block header
      ) );
 
      block_ptr->transactions = std::move( bb._pending_trx_receipts );
 
      auto id = block_ptr->calculate_id();
 
      // Update TaPoS table:
      create_block_summary( id );
 
      /*
      ilog( "finalized block ${n} (${id}) at ${t} by ${p} (${signing_key}); schedule_version: ${v} lib: ${lib} #dtrxs: ${ndtrxs} ${np}",
            ("n",pbhs.block_num)
            ("id",id)
            ("t",pbhs.timestamp)
            ("p",pbhs.producer)
            ("signing_key", pbhs.block_signing_key)
            ("v",pbhs.active_schedule_version)
            ("lib",pbhs.dpos_irreversible_blocknum)
            ("ndtrxs",db.get_index<generated_transaction_multi_index,by_trx_id>().size())
            ("np",block_ptr->new_producers)
      );
      */
 
      pending->_block_stage = assembled_block{
                                 id,
                                 std::move( bb._pending_block_header_state ),
                                 std::move( bb._pending_trx_metas ),
                                 std::move( block_ptr ),
                                 std::move( bb._new_pending_producer_schedule )
                              };
   } FC_CAPTURE_AND_RETHROW() } 

Here is the call graph for this function:

Here is the caller graph for this function:

get_deep_mind_logger()

deep_mind_handler * sysio::chain::controller_impl::get_deep_mind_logger ( ) const

inline

Definition at line 2572 of file controller.cpp.

                                                          {
      return deep_mind_logger;
   }

Here is the caller graph for this function:

get_on_block_transaction()

signed_transaction sysio::chain::controller_impl::get_on_block_transaction ( )

inline

At the start of each block we notify the system contract with a transaction that passes in the block header of the prior block (which is currently our head block)

Definition at line 2546 of file controller.cpp.

   {
      action on_block_act;
      on_block_act.account = config::system_account_name;
      on_block_act.name = "onblock"_n;
      on_block_act.authorization = vector<permission_level>{{config::system_account_name, config::active_name}};
      on_block_act.data = fc::raw::pack(self.head_block_header());
 
      signed_transaction trx;
      trx.actions.emplace_back(std::move(on_block_act));
      if( self.is_builtin_activated( builtin_protocol_feature_t::no_duplicate_deferred_id ) ) {
         trx.expiration = time_point_sec();
         trx.ref_block_num = 0;
         trx.ref_block_prefix = 0;
      } else {
         trx.expiration = self.pending_block_time() + fc::microseconds(999'999); // Round up to nearest second to avoid appearing expired
         trx.set_reference_block( self.head_block_id() );
      }
 
      if (auto dm_logger = get_deep_mind_logger()) {
         dm_logger->on_onblock(trx);
      }
 
      return trx;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

init()

void sysio::chain::controller_impl::init ( std::function< bool()> check_shutdown )

inline

Definition at line 662 of file controller.cpp.

                                                 {
      auto header_itr = validate_db_version( db );
 
      {
         const auto& state_chain_id = db.get<global_property_object>().chain_id;
         SYS_ASSERT( state_chain_id == chain_id, chain_id_type_exception,
                     "chain ID in state (${state_chain_id}) does not match the chain ID that controller was constructed with (${controller_chain_id})",
                     ("state_chain_id", state_chain_id)("controller_chain_id", chain_id)
         );
      }
 
      // upgrade to the latest compatible version
      if (header_itr->version != database_header_object::current_version) {
         db.modify(*header_itr, [](auto& header) {
            header.version = database_header_object::current_version;
         });
      }
 
      // At this point head != nullptr
      SYS_ASSERT( db.revision() >= head->block_num, fork_database_exception,
                  "fork database head (${head}) is inconsistent with state (${db})",
                  ("db",db.revision())("head",head->block_num) );
 
      if( db.revision() > head->block_num ) {
         wlog( "database revision (${db}) is greater than head block number (${head}), "
               "attempting to undo pending changes",
               ("db",db.revision())("head",head->block_num) );
      }
      while( db.revision() > head->block_num ) {
         db.undo();
      }
 
      protocol_features.init( db );
 
      if (auto dm_logger = get_deep_mind_logger()) {
         dm_logger->on_startup(db, head->block_num);
      }
 
      replay( check_shutdown ); // replay any irreversible and reversible blocks ahead of current head
 
      if( check_shutdown() ) return;
 
      // At this point head != nullptr && fork_db.head() != nullptr && fork_db.root() != nullptr.
      // Furthermore, fork_db.root()->block_num <= lib_num.
      // Also, even though blog.head() may still be nullptr, blog.first_block_num() is guaranteed to be lib_num + 1.
 
      if( read_mode != db_read_mode::IRREVERSIBLE
          && fork_db.pending_head()->id != fork_db.head()->id
          && fork_db.head()->id == fork_db.root()->id
      ) {
         wlog( "read_mode has changed from irreversible: applying best branch from fork database" );
 
         for( auto pending_head = fork_db.pending_head();
              pending_head->id != fork_db.head()->id;
              pending_head = fork_db.pending_head()
         ) {
            wlog( "applying branch from fork database ending with block: ${id}", ("id", pending_head->id) );
            maybe_switch_forks( pending_head, controller::block_status::complete, forked_branch_callback{}, trx_meta_cache_lookup{} );
         }
      }
   }

Here is the call graph for this function:

initialize_blockchain_state()

void sysio::chain::controller_impl::initialize_blockchain_state ( const genesis_state & genesis )

inline

Sets fork database head to the genesis state.

Definition at line 452 of file controller.cpp.

                                                                  {
      wlog( "Initializing new blockchain with genesis state" );
      producer_authority_schedule initial_schedule = { 0, { producer_authority{config::system_account_name, block_signing_authority_v0{ 1, {{genesis.initial_key, 1}} } } } };
      legacy::producer_schedule_type initial_legacy_schedule{ 0, {{config::system_account_name, genesis.initial_key}} };
 
      block_header_state genheader;
      genheader.active_schedule                = initial_schedule;
      genheader.pending_schedule.schedule      = initial_schedule;
      // NOTE: if wtmsig block signatures are enabled at genesis time this should be the hash of a producer authority schedule
      genheader.pending_schedule.schedule_hash = fc::sha256::hash(initial_legacy_schedule);
      genheader.header.timestamp               = genesis.initial_timestamp;
      genheader.header.action_mroot            = genesis.compute_chain_id();
      genheader.id                             = genheader.header.calculate_id();
      genheader.block_num                      = genheader.header.block_num();
 
      head = std::make_shared<block_state>();
      static_cast<block_header_state&>(*head) = genheader;
      head->activated_protocol_features = std::make_shared<protocol_feature_activation_set>();
      head->block = std::make_shared<signed_block>(genheader.header);
      db.set_revision( head->block_num );
      initialize_database(genesis);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_database()

void sysio::chain::controller_impl::initialize_database ( const genesis_state & genesis )

inline

Definition at line 1023 of file controller.cpp.

                                                          {
      // create the database header sigil
      db.create<database_header_object>([&]( auto& header ){
         // nothing to do for now
      });
 
      // Initialize block summary index
      for (int i = 0; i < 0x10000; i++)
         db.create<block_summary_object>([&](block_summary_object&) {});
 
      const auto& tapos_block_summary = db.get<block_summary_object>(1);
      db.modify( tapos_block_summary, [&]( auto& bs ) {
         bs.block_id = head->id;
      });
 
      genesis.initial_configuration.validate();
      db.create<global_property_object>([&genesis,&chain_id=this->chain_id](auto& gpo ){
         gpo.configuration = genesis.initial_configuration;
         // TODO: Update this when genesis protocol features are enabled.
         gpo.wasm_configuration = genesis_state::default_initial_wasm_configuration;
         gpo.chain_id = chain_id;
      });
 
      db.create<protocol_state_object>([&](auto& pso ){
         pso.num_supported_key_types = config::genesis_num_supported_key_types;
         for( const auto& i : genesis_intrinsics ) {
            add_intrinsic_to_whitelist( pso.whitelisted_intrinsics, i );
         }
      });
 
      db.create<dynamic_global_property_object>([](auto&){});
 
      authorization.initialize_database();
      resource_limits.initialize_database();
 
      authority system_auth(genesis.initial_key);
      create_native_account( genesis.initial_timestamp, config::system_account_name, system_auth, system_auth, true );
 
      auto empty_authority = authority(1, {}, {});
      auto active_producers_authority = authority(1, {}, {});
      active_producers_authority.accounts.push_back({{config::system_account_name, config::active_name}, 1});
 
      create_native_account( genesis.initial_timestamp, config::null_account_name, empty_authority, empty_authority );
      create_native_account( genesis.initial_timestamp, config::producers_account_name, empty_authority, active_producers_authority );
      const auto& active_permission       = authorization.get_permission({config::producers_account_name, config::active_name});
      const auto& majority_permission     = authorization.create_permission( config::producers_account_name,
                                                                             config::majority_producers_permission_name,
                                                                             active_permission.id,
                                                                             active_producers_authority,
                                                                             genesis.initial_timestamp );
                                            authorization.create_permission( config::producers_account_name,
                                                                             config::minority_producers_permission_name,
                                                                             majority_permission.id,
                                                                             active_producers_authority,
                                                                             genesis.initial_timestamp );
 
   }

Here is the call graph for this function:

Here is the caller graph for this function:

log_irreversible()

void sysio::chain::controller_impl::log_irreversible ( )

inline

Definition at line 395 of file controller.cpp.

                           {
      SYS_ASSERT( fork_db.root(), fork_database_exception, "fork database not properly initialized" );
 
      const auto& log_head = blog.head();
 
      auto lib_num = log_head ? log_head->block_num() : (blog.first_block_num() - 1);
 
      auto root_id = fork_db.root()->id;
 
      if( log_head ) {
         SYS_ASSERT( root_id == blog.head_id(), fork_database_exception, "fork database root does not match block log head" );
      } else {
         SYS_ASSERT( fork_db.root()->block_num == lib_num, fork_database_exception,
                     "empty block log expects the first appended block to build off a block that is not the fork database root. root block number: ${block_num}, lib: ${lib_num}", ("block_num", fork_db.root()->block_num) ("lib_num", lib_num) );
      }
 
      auto fork_head = (read_mode == db_read_mode::IRREVERSIBLE) ? fork_db.pending_head() : fork_db.head();
 
      if( fork_head->dpos_irreversible_blocknum <= lib_num )
         return;
 
      const auto branch = fork_db.fetch_branch( fork_head->id, fork_head->dpos_irreversible_blocknum );
      try {
 
         for( auto bitr = branch.rbegin(); bitr != branch.rend(); ++bitr ) {
            if( read_mode == db_read_mode::IRREVERSIBLE ) {
               apply_block( *bitr, controller::block_status::complete, trx_meta_cache_lookup{} );
               head = (*bitr);
               fork_db.mark_valid( head );
            }
 
            emit( self.irreversible_block, *bitr );
 
            // blog.append could fail due to failures like running out of space.
            // Do it before commit so that in case it throws, DB can be rolled back.
            blog.append( (*bitr)->block );
 
            db.commit( (*bitr)->block_num );
            root_id = (*bitr)->id;
         }
      } catch( std::exception& ) {
         if( root_id != fork_db.root()->id ) {
            fork_db.advance_root( root_id );
         }
         throw;
      }
 
      //db.commit( fork_head->dpos_irreversible_blocknum ); // redundant
 
      if( root_id != fork_db.root()->id ) {
         fork_db.advance_root( root_id );
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

make_block_restore_point()

fc::scoped_exit< std::function< void()> > sysio::chain::controller_impl::make_block_restore_point ( )

inline

Definition at line 1082 of file controller.cpp.

                                                                 {
      auto& bb = std::get<building_block>(pending->_block_stage);
      auto orig_block_transactions_size = bb._pending_trx_receipts.size();
      auto orig_state_transactions_size = bb._pending_trx_metas.size();
      auto orig_action_receipt_digests_size = bb._action_receipt_digests.size();
 
      std::function<void()> callback = [this,
                                        orig_block_transactions_size,
                                        orig_state_transactions_size,
                                        orig_action_receipt_digests_size]()
      {
         auto& bb = std::get<building_block>(pending->_block_stage);
         bb._pending_trx_receipts.resize(orig_block_transactions_size);
         bb._pending_trx_metas.resize(orig_state_transactions_size);
         bb._action_receipt_digests.resize(orig_action_receipt_digests_size);
      };
 
      return fc::make_scoped_exit( std::move(callback) );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

maybe_switch_forks()

void sysio::chain::controller_impl::maybe_switch_forks ( const block_state_ptr & new_head, controller::block_status s, const forked_branch_callback & forked_branch_cb, const trx_meta_cache_lookup & trx_lookup )

inline

end for each block in branch

Definition at line 2229 of file controller.cpp.

   {
      bool head_changed = true;
      if( new_head->header.previous == head->id ) {
         try {
            apply_block( new_head, s, trx_lookup );
            fork_db.mark_valid( new_head );
            head = new_head;
         } catch ( const std::exception& e ) {
            fork_db.remove( new_head->id );
            throw;
         }
      } else if( new_head->id != head->id ) {
         auto old_head = head;
         ilog("switching forks from ${current_head_id} (block number ${current_head_num}) to ${new_head_id} (block number ${new_head_num})",
              ("current_head_id", head->id)("current_head_num", head->block_num)("new_head_id", new_head->id)("new_head_num", new_head->block_num) );
 
         if (auto dm_logger = get_deep_mind_logger()) {
            dm_logger->on_switch_forks(head->id, new_head->id);
         }
 
         auto branches = fork_db.fetch_branch_from( new_head->id, head->id );
 
         if( branches.second.size() > 0 ) {
            for( auto itr = branches.second.begin(); itr != branches.second.end(); ++itr ) {
               pop_block();
            }
            SYS_ASSERT( self.head_block_id() == branches.second.back()->header.previous, fork_database_exception,
                     "loss of sync between fork_db and chainbase during fork switch" ); // _should_ never fail
 
            if( forked_branch_cb ) forked_branch_cb( branches.second );
         }
 
         for( auto ritr = branches.first.rbegin(); ritr != branches.first.rend(); ++ritr ) {
            auto except = std::exception_ptr{};
            try {
               apply_block( *ritr, (*ritr)->is_valid() ? controller::block_status::validated
                                                       : controller::block_status::complete, trx_lookup );
               fork_db.mark_valid( *ritr );
               head = *ritr;
            } catch ( const std::bad_alloc& ) {
              throw;
            } catch ( const boost::interprocess::bad_alloc& ) {
              throw;
            } catch (const fc::exception& e) {
               elog("exception thrown while switching forks ${e}", ("e", e.to_detail_string()));
               except = std::current_exception();
            } catch (const std::exception& e) {
               elog("exception thrown while switching forks ${e}", ("e", e.what()));
               except = std::current_exception();
            }
 
            if( except ) {
               // ritr currently points to the block that threw
               // Remove the block that threw and all forks built off it.
               fork_db.remove( (*ritr)->id );
 
               // pop all blocks from the bad fork, discarding their transactions
               // ritr base is a forward itr to the last block successfully applied
               auto applied_itr = ritr.base();
               for( auto itr = applied_itr; itr != branches.first.end(); ++itr ) {
                  pop_block();
               }
               SYS_ASSERT( self.head_block_id() == branches.second.back()->header.previous, fork_database_exception,
                           "loss of sync between fork_db and chainbase during fork switch reversal" ); // _should_ never fail
 
               // re-apply good blocks
               for( auto ritr = branches.second.rbegin(); ritr != branches.second.rend(); ++ritr ) {
                  apply_block( *ritr, controller::block_status::validated /* we previously validated these blocks*/, trx_lookup );
                  head = *ritr;
               }
               std::rethrow_exception(except);
            } // end if exception
         } 
 
         ilog("successfully switched fork to new head ${new_head_id}", ("new_head_id", new_head->id));
      } else {
         head_changed = false;
      }
 
      if( head_changed )
         log_irreversible();
 
   } 

Here is the call graph for this function:

Here is the caller graph for this function:

on_activation()

template<builtin_protocol_feature_t F>

void sysio::chain::controller_impl::on_activation

(

)

Here is the caller graph for this function:

pop_block()

void sysio::chain::controller_impl::pop_block ( )

inline

Definition at line 259 of file controller.cpp.

                    {
      auto prev = fork_db.get_block( head->header.previous );
 
      if( !prev ) {
         SYS_ASSERT( fork_db.root()->id == head->header.previous, block_validate_exception, "attempt to pop beyond last irreversible block" );
         prev = fork_db.root();
      }
 
      if ( read_mode == db_read_mode::SPECULATIVE ) {
         SYS_ASSERT( head->block, block_validate_exception, "attempting to pop a block that was sparsely loaded from a snapshot");
      }
 
      head = prev;
 
      db.undo();
 
      protocol_features.popped_blocks_to( prev->block_num );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

push_block()

void sysio::chain::controller_impl::push_block ( const block_state_ptr & bsp, const forked_branch_callback & forked_branch_cb, const trx_meta_cache_lookup & trx_lookup )

inline

Definition at line 2133 of file controller.cpp.

   {
      controller::block_status s = controller::block_status::complete;
      SYS_ASSERT(!pending, block_validate_exception, "it is not valid to push a block when there is a pending block");
 
      auto reset_prod_light_validation = fc::make_scoped_exit([old_value=trusted_producer_light_validation, this]() {
         trusted_producer_light_validation = old_value;
      });
      try {
         SYS_ASSERT( bsp, block_validate_exception, "null block" );
         const auto& b = bsp->block;
 
         if( conf.terminate_at_block > 0 && conf.terminate_at_block < self.head_block_num()) {
            ilog("Reached configured maximum block ${num}; terminating", ("num", conf.terminate_at_block) );
            shutdown();
            return;
         }
 
         emit( self.pre_accepted_block, b );
 
         fork_db.add( bsp );
 
         if (self.is_trusted_producer(b->producer)) {
            trusted_producer_light_validation = true;
         };
 
         emit( self.accepted_block_header, bsp );
 
         if( read_mode != db_read_mode::IRREVERSIBLE ) {
            maybe_switch_forks( fork_db.pending_head(), s, forked_branch_cb, trx_lookup );
         } else {
            log_irreversible();
         }
 
      } FC_LOG_AND_RETHROW( )
   }

Here is the call graph for this function:

push_receipt()

template<typename T >

const transaction_receipt & sysio::chain::controller_impl::push_receipt ( const T & trx, transaction_receipt_header::status_enum status, uint64_t cpu_usage_us, uint64_t net_usage )

inline

Adds the transaction receipt to the pending block and returns it.

Definition at line 1437 of file controller.cpp.

                                                                                        {
      uint64_t net_usage_words = net_usage / 8;
      SYS_ASSERT( net_usage_words*8 == net_usage, transaction_exception, "net_usage is not divisible by 8" );
      auto& receipts = std::get<building_block>(pending->_block_stage)._pending_trx_receipts;
      receipts.emplace_back( trx );
      transaction_receipt& r = receipts.back();
      r.cpu_usage_us         = cpu_usage_us;
      r.net_usage_words      = net_usage_words;
      r.status               = status;
      return r;
   }

Here is the caller graph for this function:

push_scheduled_transaction() [1/2]

transaction_trace_ptr sysio::chain::controller_impl::push_scheduled_transaction ( const generated_transaction_object & gto, fc::time_point block_deadline, fc::microseconds max_transaction_time, uint32_t billed_cpu_time_us, bool explicit_billed_cpu_time = false )

inline

Definition at line 1228 of file controller.cpp.

   { try {
 
      const bool validating = !self.is_producing_block();
      SYS_ASSERT( !validating || explicit_billed_cpu_time, transaction_exception, "validating requires explicit billing" );
 
      maybe_session undo_session;
      if ( !self.skip_db_sessions() )
         undo_session = maybe_session(db);
 
      auto gtrx = generated_transaction(gto);
 
      // remove the generated transaction object after making a copy
      // this will ensure that anything which affects the GTO multi-index-container will not invalidate
      // data we need to successfully retire this transaction.
      //
      // IF the transaction FAILs in a subjective way, `undo_session` should expire without being squashed
      // resulting in the GTO being restored and available for a future block to retire.
      int64_t trx_removal_ram_delta = remove_scheduled_transaction(gto);
 
      fc::datastream<const char*> ds( gtrx.packed_trx.data(), gtrx.packed_trx.size() );
 
      SYS_ASSERT( gtrx.delay_until <= self.pending_block_time(), transaction_exception, "this transaction isn't ready",
                 ("gtrx.delay_until",gtrx.delay_until)("pbt",self.pending_block_time())          );
 
      signed_transaction dtrx;
      fc::raw::unpack(ds,static_cast<transaction&>(dtrx) );
      transaction_metadata_ptr trx =
            transaction_metadata::create_no_recover_keys( std::make_shared<packed_transaction>( std::move(dtrx)  ),
                                                          transaction_metadata::trx_type::scheduled );
      trx->accepted = true;
 
      transaction_trace_ptr trace;
      if( gtrx.expiration < self.pending_block_time() ) {
         trace = std::make_shared<transaction_trace>();
         trace->id = gtrx.trx_id;
         trace->block_num = self.head_block_num() + 1;
         trace->block_time = self.pending_block_time();
         trace->producer_block_id = self.pending_producer_block_id();
         trace->scheduled = true;
         trace->receipt = push_receipt( gtrx.trx_id, transaction_receipt::expired, billed_cpu_time_us, 0 ); // expire the transaction
         trace->account_ram_delta = account_delta( gtrx.payer, trx_removal_ram_delta );
         emit( self.accepted_transaction, trx );
         dmlog_applied_transaction(trace);
         emit( self.applied_transaction, std::tie(trace, trx->packed_trx()) );
         undo_session.squash();
         return trace;
      }
 
      auto reset_in_trx_requiring_checks = fc::make_scoped_exit([old_value=in_trx_requiring_checks,this](){
         in_trx_requiring_checks = old_value;
      });
      in_trx_requiring_checks = true;
 
      uint32_t cpu_time_to_bill_us = billed_cpu_time_us;
 
      transaction_checktime_timer trx_timer(timer);
      transaction_context trx_context( self, *trx->packed_trx(), std::move(trx_timer) );
      trx_context.leeway =  fc::microseconds(0); // avoid stealing cpu resource
      trx_context.block_deadline = block_deadline;
      trx_context.max_transaction_time_subjective = max_transaction_time;
      trx_context.explicit_billed_cpu_time = explicit_billed_cpu_time;
      trx_context.billed_cpu_time_us = billed_cpu_time_us;
      trx_context.enforce_whiteblacklist = gtrx.sender.empty() ? true : !sender_avoids_whitelist_blacklist_enforcement( gtrx.sender );
      trace = trx_context.trace;
 
      auto handle_exception = [&](const auto& e)
      {
         cpu_time_to_bill_us = trx_context.update_billed_cpu_time( fc::time_point::now() );
         trace->error_code = controller::convert_exception_to_error_code( e );
         trace->except = e;
         trace->except_ptr = std::current_exception();
         trace->elapsed = fc::time_point::now() - trx_context.start;
 
         if (auto dm_logger = get_deep_mind_logger()) {
            dm_logger->on_fail_deferred();
         }
      };
 
      try {
         trx_context.init_for_deferred_trx( gtrx.published );
 
         if( trx_context.enforce_whiteblacklist && pending->_block_status == controller::block_status::incomplete ) {
            flat_set<account_name> actors;
            for( const auto& act : trx->packed_trx()->get_transaction().actions ) {
               for( const auto& auth : act.authorization ) {
                  actors.insert( auth.actor );
               }
            }
            check_actor_list( actors );
         }
 
         trx_context.exec();
         trx_context.finalize(); // Automatically rounds up network and CPU usage in trace and bills payers if successful
 
         auto restore = make_block_restore_point();
 
         trace->receipt = push_receipt( gtrx.trx_id,
                                        transaction_receipt::executed,
                                        trx_context.billed_cpu_time_us,
                                        trace->net_usage );
 
         fc::move_append( std::get<building_block>(pending->_block_stage)._action_receipt_digests,
                          std::move(trx_context.executed_action_receipt_digests) );
 
         trace->account_ram_delta = account_delta( gtrx.payer, trx_removal_ram_delta );
 
         emit( self.accepted_transaction, trx );
         dmlog_applied_transaction(trace);
         emit( self.applied_transaction, std::tie(trace, trx->packed_trx()) );
 
         trx_context.squash();
         undo_session.squash();
 
         restore.cancel();
 
         return trace;
      } catch( const disallowed_transaction_extensions_bad_block_exception& ) {
         throw;
      } catch( const protocol_feature_bad_block_exception& ) {
         throw;
      } catch ( const std::bad_alloc& ) {
         throw;
      } catch ( const boost::interprocess::bad_alloc& ) {
         throw;
      } catch( const fc::exception& e ) {
        handle_exception(e);
      } catch ( const std::exception& e) {
        auto wrapper = fc::std_exception_wrapper::from_current_exception(e);
        handle_exception(wrapper);
      }
 
      trx_context.undo();
 
      // Only subjective OR soft OR hard failure logic below:
 
      if( gtrx.sender != account_name() && !(validating ? failure_is_subjective(*trace->except) : scheduled_failure_is_subjective(*trace->except))) {
         // Attempt error handling for the generated transaction.
 
         auto error_trace = apply_onerror( gtrx, block_deadline, max_transaction_time, trx_context.pseudo_start,
                                           cpu_time_to_bill_us, billed_cpu_time_us, explicit_billed_cpu_time,
                                           trx_context.enforce_whiteblacklist );
         error_trace->failed_dtrx_trace = trace;
         trace = error_trace;
         if( !trace->except_ptr ) {
            trace->account_ram_delta = account_delta( gtrx.payer, trx_removal_ram_delta );
            emit( self.accepted_transaction, trx );
            dmlog_applied_transaction(trace);
            emit( self.applied_transaction, std::tie(trace, trx->packed_trx()) );
            undo_session.squash();
            return trace;
         }
         trace->elapsed = fc::time_point::now() - trx_context.start;
      }
 
      // Only subjective OR hard failure logic below:
 
      // subjectivity changes based on producing vs validating
      bool subjective  = false;
      if (validating) {
         subjective = failure_is_subjective(*trace->except);
      } else {
         subjective = scheduled_failure_is_subjective(*trace->except);
      }
 
      if ( !subjective ) {
         // hard failure logic
 
         if( !validating ) {
            auto& rl = self.get_mutable_resource_limits_manager();
            rl.update_account_usage( trx_context.bill_to_accounts, block_timestamp_type(self.pending_block_time()).slot );
            int64_t account_cpu_limit = 0;
            std::tie( std::ignore, account_cpu_limit, std::ignore, std::ignore ) = trx_context.max_bandwidth_billed_accounts_can_pay( true );
 
            uint32_t limited_cpu_time_to_bill_us = static_cast<uint32_t>( std::min(
                  std::min( static_cast<int64_t>(cpu_time_to_bill_us), account_cpu_limit ),
                  trx_context.initial_objective_duration_limit.count() ) );
            SYS_ASSERT( !explicit_billed_cpu_time || (cpu_time_to_bill_us == limited_cpu_time_to_bill_us),
                        transaction_exception, "cpu to bill ${cpu} != limited ${limit}", ("cpu", cpu_time_to_bill_us)("limit", limited_cpu_time_to_bill_us) );
            cpu_time_to_bill_us = limited_cpu_time_to_bill_us;
         }
 
         resource_limits.add_transaction_usage( trx_context.bill_to_accounts, cpu_time_to_bill_us, 0,
                                                block_timestamp_type(self.pending_block_time()).slot ); // Should never fail
 
         trace->receipt = push_receipt(gtrx.trx_id, transaction_receipt::hard_fail, cpu_time_to_bill_us, 0);
         trace->account_ram_delta = account_delta( gtrx.payer, trx_removal_ram_delta );
 
         emit( self.accepted_transaction, trx );
         dmlog_applied_transaction(trace);
         emit( self.applied_transaction, std::tie(trace, trx->packed_trx()) );
 
         undo_session.squash();
      } else {
         emit( self.accepted_transaction, trx );
         dmlog_applied_transaction(trace);
         emit( self.applied_transaction, std::tie(trace, trx->packed_trx()) );
      }
 
      return trace;
   } FC_CAPTURE_AND_RETHROW() } 

Here is the call graph for this function:

push_scheduled_transaction() [2/2]

transaction_trace_ptr sysio::chain::controller_impl::push_scheduled_transaction ( const transaction_id_type & trxid, fc::time_point block_deadline, fc::microseconds max_transaction_time, uint32_t billed_cpu_time_us, bool explicit_billed_cpu_time = false )

inline

Definition at line 1218 of file controller.cpp.

   {
      const auto& idx = db.get_index<generated_transaction_multi_index,by_trx_id>();
      auto itr = idx.find( trxid );
      SYS_ASSERT( itr != idx.end(), unknown_transaction_exception, "unknown transaction" );
      return push_scheduled_transaction( *itr, block_deadline, max_transaction_time, billed_cpu_time_us, explicit_billed_cpu_time );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

push_transaction()

transaction_trace_ptr sysio::chain::controller_impl::push_transaction ( const transaction_metadata_ptr & trx, fc::time_point block_deadline, fc::microseconds max_transaction_time, uint32_t billed_cpu_time_us, bool explicit_billed_cpu_time, int64_t subjective_cpu_bill_us )

inline

This is the entry point for new transactions to the block state. It will check authorization and determine whether to execute it now or to delay it. Lastly it inserts a transaction receipt into the pending block.

Definition at line 1455 of file controller.cpp.

   {
      SYS_ASSERT(block_deadline != fc::time_point(), transaction_exception, "deadline cannot be uninitialized");
 
      transaction_trace_ptr trace;
      try {
         auto start = fc::time_point::now();
         const bool check_auth = !self.skip_auth_check() && !trx->implicit;
         const fc::microseconds sig_cpu_usage = trx->signature_cpu_usage();
 
         if( !explicit_billed_cpu_time ) {
            fc::microseconds already_consumed_time( SYS_PERCENT(sig_cpu_usage.count(), conf.sig_cpu_bill_pct) );
 
            if( start.time_since_epoch() <  already_consumed_time ) {
               start = fc::time_point();
            } else {
               start -= already_consumed_time;
            }
         }
 
         const signed_transaction& trn = trx->packed_trx()->get_signed_transaction();
         transaction_checktime_timer trx_timer(timer);
         transaction_context trx_context(self, *trx->packed_trx(), std::move(trx_timer), start, trx->read_only);
         if ((bool)subjective_cpu_leeway && pending->_block_status == controller::block_status::incomplete) {
            trx_context.leeway = *subjective_cpu_leeway;
         }
         trx_context.block_deadline = block_deadline;
         trx_context.max_transaction_time_subjective = max_transaction_time;
         trx_context.explicit_billed_cpu_time = explicit_billed_cpu_time;
         trx_context.billed_cpu_time_us = billed_cpu_time_us;
         trx_context.subjective_cpu_bill_us = subjective_cpu_bill_us;
         trace = trx_context.trace;
 
         auto handle_exception =[&](const auto& e)
         {
            trace->error_code = controller::convert_exception_to_error_code( e );
            trace->except = e;
            trace->except_ptr = std::current_exception();
            trace->elapsed = fc::time_point::now() - trx_context.start;
         };
 
         try {
            if( trx->implicit ) {
               trx_context.init_for_implicit_trx();
               trx_context.enforce_whiteblacklist = false;
            } else {
               trx_context.init_for_input_trx( trx->packed_trx()->get_unprunable_size(),
                                               trx->packed_trx()->get_prunable_size() );
            }
 
            trx_context.delay = fc::seconds(trn.delay_sec);
 
            if( check_auth ) {
               authorization.check_authorization(
                       trn.actions,
                       trx->recovered_keys(),
                       {},
                       trx_context.delay,
                       [&trx_context](){ trx_context.checktime(); },
                       false,
                       trx->read_only
               );
            }
            trx_context.exec();
            trx_context.finalize(); // Automatically rounds up network and CPU usage in trace and bills payers if successful
 
            auto restore = make_block_restore_point();
 
            if (!trx->implicit) {
               transaction_receipt::status_enum s = (trx_context.delay == fc::seconds(0))
                                                    ? transaction_receipt::executed
                                                    : transaction_receipt::delayed;
               trace->receipt = push_receipt(*trx->packed_trx(), s, trx_context.billed_cpu_time_us, trace->net_usage);
               trx->billed_cpu_time_us = trx_context.billed_cpu_time_us;
               std::get<building_block>(pending->_block_stage)._pending_trx_metas.emplace_back(trx);
            } else {
               transaction_receipt_header r;
               r.status = transaction_receipt::executed;
               r.cpu_usage_us = trx_context.billed_cpu_time_us;
               r.net_usage_words = trace->net_usage / 8;
               trace->receipt = r;
            }
 
            fc::move_append( std::get<building_block>(pending->_block_stage)._action_receipt_digests,
                             std::move(trx_context.executed_action_receipt_digests) );
 
            // call the accept signal but only once for this transaction
            if (!trx->read_only) {
                if (!trx->accepted) {
                    trx->accepted = true;
                    emit(self.accepted_transaction, trx);
                }
 
                dmlog_applied_transaction(trace);
                emit(self.applied_transaction, std::tie(trace, trx->packed_trx()));
            }
 
 
            if ( (read_mode != db_read_mode::SPECULATIVE && pending->_block_status == controller::block_status::incomplete) || trx->read_only ) {
               //this may happen automatically in destructor, but I prefer make it more explicit
               trx_context.undo();
            } else {
               restore.cancel();
               trx_context.squash();
            }
 
            return trace;
         } catch( const disallowed_transaction_extensions_bad_block_exception& ) {
            throw;
         } catch( const protocol_feature_bad_block_exception& ) {
            throw;
         } catch ( const std::bad_alloc& ) {
           throw;
         } catch ( const boost::interprocess::bad_alloc& ) {
           throw;
         } catch (const fc::exception& e) {
           handle_exception(e);
         } catch (const std::exception& e) {
           auto wrapper = fc::std_exception_wrapper::from_current_exception(e);
           handle_exception(wrapper);
         }
 
         if (!trx->read_only) {
             emit(self.accepted_transaction, trx);
             dmlog_applied_transaction(trace);
             emit(self.applied_transaction, std::tie(trace, trx->packed_trx()));
         }
 
         return trace;
      } FC_CAPTURE_AND_RETHROW((trace))
   } 

Here is the call graph for this function:

Here is the caller graph for this function:

read_contract_tables_from_snapshot()

void sysio::chain::controller_impl::read_contract_tables_from_snapshot ( const snapshot_reader_ptr & snapshot )

inline

Definition at line 773 of file controller.cpp.

                                                                                  {
      snapshot->read_section("contract_tables", [this]( auto& section ) {
         bool more = !section.empty();
         while (more) {
            // read the row for the table
            table_id_object::id_type t_id;
            index_utils<table_id_multi_index>::create(db, [this, &section, &t_id](auto& row) {
               section.read_row(row, db);
               t_id = row.id;
            });
 
            // read the size and data rows for each type of table
            contract_database_index_set::walk_indices([this, &section, &t_id, &more](auto utils) {
               using utils_t = decltype(utils);
 
               unsigned_int size;
               more = section.read_row(size, db);
 
               for (size_t idx = 0; idx < size.value; idx++) {
                  utils_t::create(db, [this, &section, &more, &t_id](auto& row) {
                     row.t_id = t_id;
                     more = section.read_row(row, db);
                  });
               }
            });
         }
      });
   }

Here is the call graph for this function:

Here is the caller graph for this function:

read_from_snapshot()

void sysio::chain::controller_impl::read_from_snapshot ( const snapshot_reader_ptr & snapshot, uint32_t blog_start, uint32_t blog_end )

inline

load and upgrade the block header state

Definition at line 853 of file controller.cpp.

                                                                                                          {
      chain_snapshot_header header;
      snapshot->read_section<chain_snapshot_header>([this, &header]( auto &section ){
         section.read_row(header, db);
         header.validate();
      });
 
      { 
         block_header_state head_header_state;
         using v2 = legacy::snapshot_block_header_state_v2;
 
         if (std::clamp(header.version, v2::minimum_version, v2::maximum_version) == header.version ) {
            snapshot->read_section<block_state>([this, &head_header_state]( auto &section ) {
               legacy::snapshot_block_header_state_v2 legacy_header_state;
               section.read_row(legacy_header_state, db);
               head_header_state = block_header_state(std::move(legacy_header_state));
            });
         } else {
            snapshot->read_section<block_state>([this,&head_header_state]( auto &section ){
               section.read_row(head_header_state, db);
            });
         }
 
         snapshot_head_block = head_header_state.block_num;
         SYS_ASSERT( blog_start <= (snapshot_head_block + 1) && snapshot_head_block <= blog_end,
                     block_log_exception,
                     "Block log is provided with snapshot but does not contain the head block from the snapshot nor a block right after it",
                     ("snapshot_head_block", snapshot_head_block)
                     ("block_log_first_num", blog_start)
                     ("block_log_last_num", blog_end)
         );
 
         head = std::make_shared<block_state>();
         static_cast<block_header_state&>(*head) = head_header_state;
      }
 
      controller_index_set::walk_indices([this, &snapshot, &header]( auto utils ){
         using value_t = typename decltype(utils)::index_t::value_type;
 
         // skip the table_id_object as its inlined with contract tables section
         if (std::is_same<value_t, table_id_object>::value) {
            return;
         }
 
         // skip the database_header as it is only relevant to in-memory database
         if (std::is_same<value_t, database_header_object>::value) {
            return;
         }
 
         // special case for in-place upgrade of global_property_object
         if (std::is_same<value_t, global_property_object>::value) {
            using v2 = legacy::snapshot_global_property_object_v2;
            using v3 = legacy::snapshot_global_property_object_v3;
            using v4 = legacy::snapshot_global_property_object_v4;
 
            if (std::clamp(header.version, v2::minimum_version, v2::maximum_version) == header.version ) {
               std::optional<genesis_state> genesis = extract_legacy_genesis_state(*snapshot, header.version);
               SYS_ASSERT( genesis, snapshot_exception,
                           "Snapshot indicates chain_snapshot_header version 2, but does not contain a genesis_state. "
                           "It must be corrupted.");
               snapshot->read_section<global_property_object>([&db=this->db,gs_chain_id=genesis->compute_chain_id()]( auto &section ) {
                  v2 legacy_global_properties;
                  section.read_row(legacy_global_properties, db);
 
                  db.create<global_property_object>([&legacy_global_properties,&gs_chain_id](auto& gpo ){
                     gpo.initalize_from(legacy_global_properties, gs_chain_id, kv_database_config{},
                                       genesis_state::default_initial_wasm_configuration);
                  });
               });
               return; // early out to avoid default processing
            }
 
            if (std::clamp(header.version, v3::minimum_version, v3::maximum_version) == header.version ) {
               snapshot->read_section<global_property_object>([&db=this->db]( auto &section ) {
                  v3 legacy_global_properties;
                  section.read_row(legacy_global_properties, db);
 
                  db.create<global_property_object>([&legacy_global_properties](auto& gpo ){
                     gpo.initalize_from(legacy_global_properties, kv_database_config{},
                                        genesis_state::default_initial_wasm_configuration);
                  });
               });
               return; // early out to avoid default processing
            }
 
            if (std::clamp(header.version, v4::minimum_version, v4::maximum_version) == header.version) {
               snapshot->read_section<global_property_object>([&db = this->db](auto& section) {
                  v4 legacy_global_properties;
                  section.read_row(legacy_global_properties, db);
 
                  db.create<global_property_object>([&legacy_global_properties](auto& gpo) {
                     gpo.initalize_from(legacy_global_properties);
                  });
               });
               return; // early out to avoid default processing
            }
         }
 
         snapshot->read_section<value_t>([this]( auto& section ) {
            bool more = !section.empty();
            while(more) {
               decltype(utils)::create(db, [this, &section, &more]( auto &row ) {
                  more = section.read_row(row, db);
               });
            }
         });
      });
 
      read_contract_tables_from_snapshot(snapshot);
 
      authorization.read_from_snapshot(snapshot);
      resource_limits.read_from_snapshot(snapshot);
 
      db.set_revision( head->block_num );
      db.create<database_header_object>([](const auto& header){
         // nothing to do
      });
 
      const auto& gpo = db.get<global_property_object>();
      SYS_ASSERT( gpo.chain_id == chain_id, chain_id_type_exception,
                  "chain ID in snapshot (${snapshot_chain_id}) does not match the chain ID that controller was constructed with (${controller_chain_id})",
                  ("snapshot_chain_id", gpo.chain_id)("controller_chain_id", chain_id)
      );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

remove_scheduled_transaction()

int64_t sysio::chain::controller_impl::remove_scheduled_transaction ( const generated_transaction_object & gto )

inline

Definition at line 1180 of file controller.cpp.

                                                                                   {
      if (auto dm_logger = get_deep_mind_logger()) {
         dm_logger->on_ram_trace(RAM_EVENT_ID("${id}", ("id", gto.id)), "deferred_trx", "remove", "deferred_trx_removed");
      }
 
      int64_t ram_delta = -(config::billable_size_v<generated_transaction_object> + gto.packed_trx.size());
      resource_limits.add_pending_ram_usage( gto.payer, ram_delta );
      // No need to verify_account_ram_usage since we are only reducing memory
 
      db.remove( gto );
      return ram_delta;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

replay()

void sysio::chain::controller_impl::replay ( std::function< bool()> check_shutdown )

inline

Definition at line 475 of file controller.cpp.

                                                   {
      if( !blog.head() && !fork_db.root() ) {
         fork_db.reset( *head );
         return;
      }
 
      auto blog_head = blog.head();
      replaying = true;
      auto start_block_num = head->block_num + 1;
      auto start = fc::time_point::now();
 
      std::exception_ptr except_ptr;
 
      if( blog_head && start_block_num <= blog_head->block_num() ) {
         ilog( "existing block log, attempting to replay from ${s} to ${n} blocks",
               ("s", start_block_num)("n", blog_head->block_num()) );
         try {
            while( auto next = blog.read_block_by_num( head->block_num + 1 ) ) {
               replay_push_block( next, controller::block_status::irreversible );
               if( check_shutdown() ) break;
               if( next->block_num() % 500 == 0 ) {
                  ilog( "${n} of ${head}", ("n", next->block_num())("head", blog_head->block_num()) );
               }
            }
         } catch(  const database_guard_exception& e ) {
            except_ptr = std::current_exception();
         }
         ilog( "${n} irreversible blocks replayed", ("n", 1 + head->block_num - start_block_num) );
 
         auto pending_head = fork_db.pending_head();
         if( pending_head ) {
            ilog( "fork database head ${h}, root ${r}", ("h", pending_head->block_num)( "r", fork_db.root()->block_num ) );
            if( pending_head->block_num < head->block_num || head->block_num < fork_db.root()->block_num ) {
               ilog( "resetting fork database with new last irreversible block as the new root: ${id}", ("id", head->id) );
               fork_db.reset( *head );
            } else if( head->block_num != fork_db.root()->block_num ) {
               auto new_root = fork_db.search_on_branch( pending_head->id, head->block_num );
               SYS_ASSERT( new_root, fork_database_exception,
                           "unexpected error: could not find new LIB in fork database" );
               ilog( "advancing fork database root to new last irreversible block within existing fork database: ${id}",
                     ("id", new_root->id) );
               fork_db.mark_valid( new_root );
               fork_db.advance_root( new_root->id );
            }
         }
 
         // if the irreverible log is played without undo sessions enabled, we need to sync the
         // revision ordinal to the appropriate expected value here.
         if( self.skip_db_sessions( controller::block_status::irreversible ) )
            db.set_revision( head->block_num );
      } else {
         ilog( "no irreversible blocks need to be replayed" );
      }
 
      if( !except_ptr && !check_shutdown() && fork_db.head() ) {
         auto head_block_num = head->block_num;
         auto branch = fork_db.fetch_branch( fork_db.head()->id );
         int rev = 0;
         for( auto i = branch.rbegin(); i != branch.rend(); ++i ) {
            if( check_shutdown() ) break;
            if( (*i)->block_num <= head_block_num ) continue;
            ++rev;
            replay_push_block( (*i)->block, controller::block_status::validated );
         }
         ilog( "${n} reversible blocks replayed", ("n",rev) );
      }
 
      if( !fork_db.head() ) {
         fork_db.reset( *head );
      }
 
      auto end = fc::time_point::now();
      ilog( "replayed ${n} blocks in ${duration} seconds, ${mspb} ms/block",
            ("n", head->block_num + 1 - start_block_num)("duration", (end-start).count()/1000000)
            ("mspb", ((end-start).count()/1000.0)/(head->block_num-start_block_num)) );
      replaying = false;
 
      if( except_ptr ) {
         std::rethrow_exception( except_ptr );
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

replay_push_block()

void sysio::chain::controller_impl::replay_push_block ( const signed_block_ptr & b, controller::block_status s )

inline

Definition at line 2172 of file controller.cpp.

                                                                                 {
      self.validate_db_available_size();
 
      SYS_ASSERT(!pending, block_validate_exception, "it is not valid to push a block when there is a pending block");
 
      try {
         SYS_ASSERT( b, block_validate_exception, "trying to push empty block" );
         SYS_ASSERT( (s == controller::block_status::irreversible || s == controller::block_status::validated),
                     block_validate_exception, "invalid block status for replay" );
 
         if( conf.terminate_at_block > 0 && conf.terminate_at_block < self.head_block_num() ) {
            ilog("Reached configured maximum block ${num}; terminating", ("num", conf.terminate_at_block) );
            shutdown();
            return;
         }
 
         emit( self.pre_accepted_block, b );
         const bool skip_validate_signee = !conf.force_all_checks;
 
         auto bsp = std::make_shared<block_state>(
                        *head,
                        b,
                        protocol_features.get_protocol_feature_set(),
                        [this]( block_timestamp_type timestamp,
                                const flat_set<digest_type>& cur_features,
                                const vector<digest_type>& new_features )
                        { check_protocol_features( timestamp, cur_features, new_features ); },
                        skip_validate_signee
         );
 
         if( s != controller::block_status::irreversible ) {
            fork_db.add( bsp, true );
         }
 
         emit( self.accepted_block_header, bsp );
 
         if( s == controller::block_status::irreversible ) {
            apply_block( bsp, s, trx_meta_cache_lookup{} );
            head = bsp;
 
            // On replay, log_irreversible is not called and so no irreversible_block signal is emitted.
            // So emit it explicitly here.
            emit( self.irreversible_block, bsp );
 
            if (!self.skip_db_sessions(s)) {
               db.commit(bsp->block_num);
            }
 
         } else {
            SYS_ASSERT( read_mode != db_read_mode::IRREVERSIBLE, block_validate_exception,
                        "invariant failure: cannot replay reversible blocks while in irreversible mode" );
            maybe_switch_forks( bsp, s, forked_branch_callback{}, trx_meta_cache_lookup{} );
         }
 
      } FC_LOG_AND_RETHROW( )
   }

Here is the call graph for this function:

Here is the caller graph for this function:

report_block_header_diff()

void sysio::chain::controller_impl::report_block_header_diff ( const block_header & b, const block_header & ab )

inline

Definition at line 1927 of file controller.cpp.

                                                                                  {
 
#define SYS_REPORT(DESC,A,B) \
   if( A != B ) { \
      elog("${desc}: ${bv} != ${abv}", ("desc", DESC)("bv", A)("abv", B)); \
   }
 
      SYS_REPORT( "timestamp", b.timestamp, ab.timestamp )
      SYS_REPORT( "producer", b.producer, ab.producer )
      SYS_REPORT( "confirmed", b.confirmed, ab.confirmed )
      SYS_REPORT( "previous", b.previous, ab.previous )
      SYS_REPORT( "transaction_mroot", b.transaction_mroot, ab.transaction_mroot )
      SYS_REPORT( "action_mroot", b.action_mroot, ab.action_mroot )
      SYS_REPORT( "schedule_version", b.schedule_version, ab.schedule_version )
      SYS_REPORT( "new_producers", b.new_producers, ab.new_producers )
      SYS_REPORT( "header_extensions", b.header_extensions, ab.header_extensions )
 
#undef SYS_REPORT
   }

Here is the caller graph for this function:

scheduled_failure_is_subjective()

bool sysio::chain::controller_impl::scheduled_failure_is_subjective ( const fc::exception & e ) const

inline

Definition at line 1212 of file controller.cpp.

                                                                      {
      auto code = e.code();
      return    (code == tx_cpu_usage_exceeded::code_value)
             || failure_is_subjective(e);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

sender_avoids_whitelist_blacklist_enforcement()

bool sysio::chain::controller_impl::sender_avoids_whitelist_blacklist_enforcement ( account_name sender ) const

inline

Definition at line 2397 of file controller.cpp.

                                                                                  {
      if( conf.sender_bypass_whiteblacklist.size() > 0 &&
          ( conf.sender_bypass_whiteblacklist.find( sender ) != conf.sender_bypass_whiteblacklist.end() ) )
      {
         return true;
      }
 
      return false;
   }

Here is the caller graph for this function:

set_activation_handler()

template<builtin_protocol_feature_t F>

void sysio::chain::controller_impl::set_activation_handler ( )

inline

Definition at line 282 of file controller.cpp.

                                        {
      auto res = protocol_feature_activation_handlers.emplace( F, &controller_impl::on_activation<F> );
      SYS_ASSERT( res.second, misc_exception, "attempting to set activation handler twice" );
   }

Here is the call graph for this function:

set_apply_handler()

void sysio::chain::controller_impl::set_apply_handler ( account_name receiver, account_name contract, action_name action, apply_handler v )

inline

Definition at line 293 of file controller.cpp.

                                                                                                               {
      apply_handlers[receiver][make_pair(contract,action)] = v;
   }

start_block()

void sysio::chain::controller_impl::start_block ( block_timestamp_type when, uint16_t confirm_block_count, const vector< digest_type > & new_protocol_feature_activations, controller::block_status s, const std::optional< block_id_type > & producer_block_id, const fc::time_point & deadline )

inline

Definition at line 1592 of file controller.cpp.

   {
      SYS_ASSERT( !pending, block_validate_exception, "pending block already exists" );
 
      emit( self.block_start, head->block_num + 1 );
 
      if (auto dm_logger = get_deep_mind_logger()) {
         // The head block represents the block just before this one that is about to start, so add 1 to get this block num
         dm_logger->on_start_block(head->block_num + 1);
      }
 
      auto guard_pending = fc::make_scoped_exit([this, head_block_num=head->block_num](){
         protocol_features.popped_blocks_to( head_block_num );
         pending.reset();
      });
 
      if (!self.skip_db_sessions(s)) {
         SYS_ASSERT( db.revision() == head->block_num, database_exception, "db revision is not on par with head block",
                     ("db.revision()", db.revision())("controller_head_block", head->block_num)("fork_db_head_block", fork_db.head()->block_num) );
 
         pending.emplace( maybe_session(db), *head, when, confirm_block_count, new_protocol_feature_activations );
      } else {
         pending.emplace( maybe_session(), *head, when, confirm_block_count, new_protocol_feature_activations );
      }
 
      pending->_block_status = s;
      pending->_producer_block_id = producer_block_id;
 
      auto& bb = std::get<building_block>(pending->_block_stage);
      const auto& pbhs = bb._pending_block_header_state;
 
      // modify state of speculative block only if we are in speculative read mode (otherwise we need clean state for head or read-only modes)
      if ( read_mode == db_read_mode::SPECULATIVE || pending->_block_status != controller::block_status::incomplete )
      {
         const auto& pso = db.get<protocol_state_object>();
 
         auto num_preactivated_protocol_features = pso.preactivated_protocol_features.size();
         bool handled_all_preactivated_features = (num_preactivated_protocol_features == 0);
 
         if( new_protocol_feature_activations.size() > 0 ) {
            flat_map<digest_type, bool> activated_protocol_features;
            activated_protocol_features.reserve( std::max( num_preactivated_protocol_features,
                                                           new_protocol_feature_activations.size() ) );
            for( const auto& feature_digest : pso.preactivated_protocol_features ) {
               activated_protocol_features.emplace( feature_digest, false );
            }
 
            size_t num_preactivated_features_that_have_activated = 0;
 
            const auto& pfs = protocol_features.get_protocol_feature_set();
            for( const auto& feature_digest : new_protocol_feature_activations ) {
               const auto& f = pfs.get_protocol_feature( feature_digest );
 
               auto res = activated_protocol_features.emplace( feature_digest, true );
               if( res.second ) {
                  // feature_digest was not preactivated
                  SYS_ASSERT( !f.preactivation_required, protocol_feature_exception,
                              "attempted to activate protocol feature without prior required preactivation: ${digest}",
                              ("digest", feature_digest)
                  );
               } else {
                  SYS_ASSERT( !res.first->second, block_validate_exception,
                              "attempted duplicate activation within a single block: ${digest}",
                              ("digest", feature_digest)
                  );
                  // feature_digest was preactivated
                  res.first->second = true;
                  ++num_preactivated_features_that_have_activated;
               }
 
               if( f.builtin_feature ) {
                  trigger_activation_handler( *f.builtin_feature );
               }
 
               protocol_features.activate_feature( feature_digest, pbhs.block_num );
 
               ++bb._num_new_protocol_features_that_have_activated;
            }
 
            if( num_preactivated_features_that_have_activated == num_preactivated_protocol_features ) {
               handled_all_preactivated_features = true;
            }
         }
 
         SYS_ASSERT( handled_all_preactivated_features, block_validate_exception,
                     "There are pre-activated protocol features that were not activated at the start of this block"
         );
 
         if( new_protocol_feature_activations.size() > 0 ) {
            db.modify( pso, [&]( auto& ps ) {
               ps.preactivated_protocol_features.clear();
 
               ps.activated_protocol_features.reserve( ps.activated_protocol_features.size()
                                                         + new_protocol_feature_activations.size() );
               for( const auto& feature_digest : new_protocol_feature_activations ) {
                  ps.activated_protocol_features.emplace_back( feature_digest, pbhs.block_num );
               }
            });
         }
 
         const auto& gpo = db.get<global_property_object>();
 
         if( gpo.proposed_schedule_block_num && // if there is a proposed schedule that was proposed in a block ...
             ( *gpo.proposed_schedule_block_num <= pbhs.dpos_irreversible_blocknum ) && // ... that has now become irreversible ...
             pbhs.prev_pending_schedule.schedule.producers.size() == 0 // ... and there was room for a new pending schedule prior to any possible promotion
         )
         {
            // Promote proposed schedule to pending schedule.
            if( !replaying ) {
               ilog( "promoting proposed schedule (set in block ${proposed_num}) to pending; current block: ${n} lib: ${lib} schedule: ${schedule} ",
                     ("proposed_num", *gpo.proposed_schedule_block_num)("n", pbhs.block_num)
                     ("lib", pbhs.dpos_irreversible_blocknum)
                     ("schedule", producer_authority_schedule::from_shared(gpo.proposed_schedule) ) );
            }
 
            SYS_ASSERT( gpo.proposed_schedule.version == pbhs.active_schedule_version + 1,
                        producer_schedule_exception, "wrong producer schedule version specified" );
 
            std::get<building_block>(pending->_block_stage)._new_pending_producer_schedule = producer_authority_schedule::from_shared(gpo.proposed_schedule);
            db.modify( gpo, [&]( auto& gp ) {
               gp.proposed_schedule_block_num = std::optional<block_num_type>();
               gp.proposed_schedule.version=0;
               gp.proposed_schedule.producers.clear();
            });
         }
 
         try {
            transaction_metadata_ptr onbtrx =
                  transaction_metadata::create_no_recover_keys( std::make_shared<packed_transaction>( get_on_block_transaction() ),
                                                                transaction_metadata::trx_type::implicit );
            auto reset_in_trx_requiring_checks = fc::make_scoped_exit([old_value=in_trx_requiring_checks,this](){
                  in_trx_requiring_checks = old_value;
               });
            in_trx_requiring_checks = true;
            auto trace = push_transaction( onbtrx, fc::time_point::maximum(), fc::microseconds::maximum(),
                                           self.get_global_properties().configuration.min_transaction_cpu_usage, true, 0 );
            if( trace->except ) {
               wlog("onblock ${block_num} is REJECTING: ${entire_trace}",("block_num", head->block_num + 1)("entire_trace", trace));
            }
         } catch( const std::bad_alloc& e ) {
            elog( "on block transaction failed due to a std::bad_alloc" );
            throw;
         } catch( const boost::interprocess::bad_alloc& e ) {
            elog( "on block transaction failed due to a bad allocation" );
            throw;
         } catch( const fc::exception& e ) {
            wlog( "on block transaction failed, but shouldn't impact block generation, system contract needs update" );
            edump((e.to_detail_string()));
         } catch( const std::exception& e ) {
            wlog( "on block transaction failed due to unexpected exception" );
            edump((e.what()));
         } catch( ... ) {
            elog( "on block transaction failed due to unknown exception" );
         }
 
         clear_expired_input_transactions(deadline);
         update_producers_authority();
      }
 
      guard_pending.cancel();
   } 

Here is the call graph for this function:

Here is the caller graph for this function:

startup() [1/3]

void sysio::chain::controller_impl::startup ( std::function< void()> shutdown, std::function< bool()> check_shutdown )

inline

Definition at line 618 of file controller.cpp.

                                                                                  {
      SYS_ASSERT( db.revision() >= 1, database_exception, "This version of controller::startup does not work with a fresh state database." );
      SYS_ASSERT( fork_db.head(), fork_database_exception, "No existing fork database despite existing chain state. Replay required." );
 
      this->shutdown = shutdown;
      uint32_t lib_num = fork_db.root()->block_num;
      auto first_block_num = blog.first_block_num();
      if( blog.head() ) {
         SYS_ASSERT( first_block_num <= lib_num && lib_num <= blog.head()->block_num(),
                     block_log_exception,
                     "block log (ranging from ${block_log_first_num} to ${block_log_last_num}) does not contain the last irreversible block (${fork_db_lib})",
                     ("block_log_first_num", first_block_num)
                     ("block_log_last_num", blog.head()->block_num())
                     ("fork_db_lib", lib_num)
         );
         lib_num = blog.head()->block_num();
      } else {
         if( first_block_num != (lib_num + 1) ) {
            blog.reset( chain_id, lib_num + 1 );
         }
      }
 
      if( read_mode == db_read_mode::IRREVERSIBLE && fork_db.head()->id != fork_db.root()->id ) {
         fork_db.rollback_head_to_root();
      }
      head = fork_db.head();
 
      init(check_shutdown);
   }

Here is the call graph for this function:

startup() [2/3]

void sysio::chain::controller_impl::startup ( std::function< void()> shutdown, std::function< bool()> check_shutdown, const genesis_state & genesis )

inline

Definition at line 585 of file controller.cpp.

                                                                                                                {
      SYS_ASSERT( db.revision() < 1, database_exception, "This version of controller::startup only works with a fresh state database." );
      const auto& genesis_chain_id = genesis.compute_chain_id();
      SYS_ASSERT( genesis_chain_id == chain_id, chain_id_type_exception,
                  "genesis state provided to startup corresponds to a chain ID (${genesis_chain_id}) that does not match the chain ID that controller was constructed with (${controller_chain_id})",
                  ("genesis_chain_id", genesis_chain_id)("controller_chain_id", chain_id)
      );
 
      this->shutdown = shutdown;
      if( fork_db.head() ) {
         if( read_mode == db_read_mode::IRREVERSIBLE && fork_db.head()->id != fork_db.root()->id ) {
            fork_db.rollback_head_to_root();
         }
         wlog( "No existing chain state. Initializing fresh blockchain state." );
      } else {
         wlog( "No existing chain state or fork database. Initializing fresh blockchain state and resetting fork database.");
      }
      initialize_blockchain_state(genesis); // sets head to genesis state
 
      if( !fork_db.head() ) {
         fork_db.reset( *head );
      }
 
      if( blog.head() ) {
         SYS_ASSERT( blog.first_block_num() == 1, block_log_exception,
                     "block log does not start with genesis block"
         );
      } else {
         blog.reset( genesis, head->block );
      }
      init(check_shutdown);
   }

Here is the call graph for this function:

startup() [3/3]

void sysio::chain::controller_impl::startup ( std::function< void()> shutdown, std::function< bool()> check_shutdown, const snapshot_reader_ptr & snapshot )

inline

Definition at line 557 of file controller.cpp.

                                                                                                                       {
      SYS_ASSERT( snapshot, snapshot_exception, "No snapshot reader provided" );
      this->shutdown = shutdown;
      ilog( "Starting initialization from snapshot, this may take a significant amount of time" );
      try {
         snapshot->validate();
         if( blog.head() ) {
            read_from_snapshot( snapshot, blog.first_block_num(), blog.head()->block_num() );
         } else {
            read_from_snapshot( snapshot, 0, std::numeric_limits<uint32_t>::max() );
            const uint32_t lib_num = head->block_num;
            SYS_ASSERT( lib_num > 0, snapshot_exception,
                        "Snapshot indicates controller head at block number 0, but that is not allowed. "
                        "Snapshot is invalid." );
            blog.reset( chain_id, lib_num + 1 );
         }
         const auto hash = calculate_integrity_hash();
         ilog( "database initialized with hash: ${hash}", ("hash", hash) );
 
         init(check_shutdown);
         ilog( "Finished initialization from snapshot" );
      } catch (boost::interprocess::bad_alloc& e) {
         elog( "Failed initialization from snapshot - db storage not configured to have enough storage for the provided snapshot, please increase and retry snapshot" );
         shutdown();
      }
 
   }

Here is the call graph for this function:

trigger_activation_handler()

void sysio::chain::controller_impl::trigger_activation_handler ( builtin_protocol_feature_t f )

inline

Definition at line 287 of file controller.cpp.

                                                                          {
      auto itr = protocol_feature_activation_handlers.find( f );
      if( itr == protocol_feature_activation_handlers.end() ) return;
      (itr->second)( *this );
   }

Here is the caller graph for this function:

update_producers_authority()

void sysio::chain::controller_impl::update_producers_authority ( )

inline

Definition at line 2334 of file controller.cpp.

                                     {
      const auto& producers = pending->get_pending_block_header_state().active_schedule.producers;
 
      auto update_permission = [&]( auto& permission, auto threshold ) {
         auto auth = authority( threshold, {}, {});
         for( auto& p : producers ) {
            auth.accounts.push_back({{p.producer_name, config::active_name}, 1});
         }
 
         if( static_cast<authority>(permission.auth) != auth ) { // TODO: use a more efficient way to check that authority has not changed
            db.modify(permission, [&]( auto& po ) {
               po.auth = auth;
            });
         }
      };
 
      uint32_t num_producers = producers.size();
      auto calculate_threshold = [=]( uint32_t numerator, uint32_t denominator ) {
         return ( (num_producers * numerator) / denominator ) + 1;
      };
 
      update_permission( authorization.get_permission({config::producers_account_name,
                                                       config::active_name}),
                         calculate_threshold( 2, 3 ) /* more than two-thirds */                      );
 
      update_permission( authorization.get_permission({config::producers_account_name,
                                                       config::majority_producers_permission_name}),
                         calculate_threshold( 1, 2 ) /* more than one-half */                        );
 
      update_permission( authorization.get_permission({config::producers_account_name,
                                                       config::minority_producers_permission_name}),
                         calculate_threshold( 1, 3 ) /* more than one-third */                       );
 
      //TODO: Add tests
   }

Here is the call graph for this function:

Here is the caller graph for this function:

validate_db_version()

static auto sysio::chain::controller_impl::validate_db_version ( const chainbase::database & db )

inlinestatic

Definition at line 649 of file controller.cpp.

                                                                  {
      // check database version
      const auto& header_idx = db.get_index<database_header_multi_index>().indices().get<by_id>();
 
      SYS_ASSERT(header_idx.begin() != header_idx.end(), bad_database_version_exception,
                 "state database version pre-dates versioning, please restore from a compatible snapshot or replay!");
 
      auto header_itr = header_idx.begin();
      header_itr->validate();
 
      return header_itr;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

apply_handlers

map< account_name, map<handler_key, apply_handler> > sysio::chain::controller_impl::apply_handlers

Definition at line 256 of file controller.cpp.

authorization

authorization_manager sysio::chain::controller_impl::authorization

Definition at line 238 of file controller.cpp.

blog

block_log sysio::chain::controller_impl::blog

Definition at line 232 of file controller.cpp.

chain_id

const chain_id_type sysio::chain::controller_impl::chain_id

Definition at line 241 of file controller.cpp.

conf

controller::config sysio::chain::controller_impl::conf

Definition at line 240 of file controller.cpp.

db

chainbase::database sysio::chain::controller_impl::db

Definition at line 231 of file controller.cpp.

deep_mind_logger

deep_mind_handler* sysio::chain::controller_impl::deep_mind_logger = nullptr

Definition at line 250 of file controller.cpp.

fork_db

fork_database sysio::chain::controller_impl::fork_db

Definition at line 235 of file controller.cpp.

head

block_state_ptr sysio::chain::controller_impl::head

Definition at line 234 of file controller.cpp.

in_trx_requiring_checks

bool sysio::chain::controller_impl::in_trx_requiring_checks = false

Definition at line 244 of file controller.cpp.

pending

std::optional<pending_state> sysio::chain::controller_impl::pending

Definition at line 233 of file controller.cpp.

protocol_feature_activation_handlers

unordered_map< builtin_protocol_feature_t, std::function<void(controller_impl&)>, enum_hash<builtin_protocol_feature_t> > sysio::chain::controller_impl::protocol_feature_activation_handlers

Definition at line 257 of file controller.cpp.

protocol_features

protocol_feature_manager sysio::chain::controller_impl::protocol_features

Definition at line 239 of file controller.cpp.

read_mode

db_read_mode sysio::chain::controller_impl::read_mode = db_read_mode::SPECULATIVE

Definition at line 243 of file controller.cpp.

replaying

bool sysio::chain::controller_impl::replaying = false

Definition at line 242 of file controller.cpp.

resource_limits

resource_limits_manager sysio::chain::controller_impl::resource_limits

Definition at line 237 of file controller.cpp.

rnh

reset_new_handler sysio::chain::controller_impl::rnh

Definition at line 228 of file controller.cpp.

self

controller& sysio::chain::controller_impl::self

Definition at line 229 of file controller.cpp.

shutdown

std::function<void()> sysio::chain::controller_impl::shutdown

Definition at line 230 of file controller.cpp.

snapshot_head_block

uint32_t sysio::chain::controller_impl::snapshot_head_block = 0

Definition at line 247 of file controller.cpp.

subjective_cpu_leeway

std::optional<fc::microseconds> sysio::chain::controller_impl::subjective_cpu_leeway

Definition at line 245 of file controller.cpp.

thread_pool

named_thread_pool sysio::chain::controller_impl::thread_pool

Definition at line 248 of file controller.cpp.

timer

platform_timer sysio::chain::controller_impl::timer

Definition at line 249 of file controller.cpp.

trusted_producer_light_validation

bool sysio::chain::controller_impl::trusted_producer_light_validation = false

Definition at line 246 of file controller.cpp.

wasmif

wasm_interface sysio::chain::controller_impl::wasmif

Definition at line 236 of file controller.cpp.

---

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

• libraries/chain/controller.cpp