sysio::chain::transaction_context Class Reference

#include <transaction_context.hpp>

Collaboration diagram for sysio::chain::transaction_context:

Public Member Functions
	transaction_context (controller &c, const packed_transaction &t, transaction_checktime_timer &&timer, fc::time_point start=fc::time_point::now(), bool read_only=false)
	~transaction_context ()
void	init_for_implicit_trx (uint64_t initial_net_usage=0)
void	init_for_input_trx (uint64_t packed_trx_unprunable_size, uint64_t packed_trx_prunable_size)
void	init_for_deferred_trx (fc::time_point published)
void	exec ()
void	finalize ()
void	squash ()
void	undo ()
void	add_net_usage (uint64_t u)
void	check_net_usage () const
void	checktime () const
template<typename DigestType >
DigestType	hash_with_checktime (const char *data, uint32_t datalen) const
void	pause_billing_timer ()
void	resume_billing_timer ()
uint32_t	update_billed_cpu_time (fc::time_point now)
std::tuple< int64_t, int64_t, bool, bool >	max_bandwidth_billed_accounts_can_pay (bool force_elastic_limits=false) const
void	validate_referenced_accounts (const transaction &trx, bool enforce_actor_whitelist_blacklist) const
	record_transaction

Public Attributes
controller &	control
	Fields:
const packed_transaction &	packed_trx
std::optional< chainbase::database::session >	undo_session
transaction_trace_ptr	trace
fc::time_point	start
fc::time_point	published
vector< digest_type >	executed_action_receipt_digests
flat_set< account_name >	bill_to_accounts
flat_set< account_name >	validate_ram_usage
uint64_t	initial_max_billable_cpu = 0
	the maximum number of virtual CPU instructions of the transaction that can be safely billed to the billable accounts
fc::microseconds	delay
bool	is_input = false
bool	apply_context_free = true
bool	enforce_whiteblacklist = true
fc::time_point	block_deadline = fc::time_point::maximum()
fc::microseconds	leeway = fc::microseconds( config::default_subjective_cpu_leeway_us )
int64_t	billed_cpu_time_us = 0
int64_t	subjective_cpu_bill_us = 0
bool	explicit_billed_cpu_time = false
transaction_checktime_timer	transaction_timer
const bool	is_read_only

Friends
struct	controller_impl
class	apply_context

Detailed Description

Definition at line 32 of file transaction_context.hpp.

Constructor & Destructor Documentation

transaction_context()

sysio::chain::transaction_context::transaction_context	(	controller &	c,
		const packed_transaction &	t,
		transaction_checktime_timer &&	timer,
		fc::time_point	start = fc::time_point::now(),
		bool	read_only = false )

Definition at line 47 of file transaction_context.cpp.

   :control(c)
   ,packed_trx(t)
   ,undo_session()
   ,trace(std::make_shared<transaction_trace>())
   ,start(s)
   ,transaction_timer(std::move(tmr))
   ,is_read_only(read_only)
   ,net_usage(trace->net_usage)
   ,pseudo_start(s)
   {
      if (!c.skip_db_sessions()) {
         undo_session.emplace(c.mutable_db().start_undo_session(true));
      }
      trace->id = packed_trx.id();
      trace->block_num = c.head_block_num() + 1;
      trace->block_time = c.pending_block_time();
      trace->producer_block_id = c.pending_producer_block_id();
 
      if(auto dm_logger = control.get_deep_mind_logger())
      {
         dm_logger->on_start_transaction();
      }
   }

Here is the call graph for this function:

~transaction_context()

sysio::chain::transaction_context::~transaction_context

(

)

Definition at line 76 of file transaction_context.cpp.

   {
      if(auto dm_logger = control.get_deep_mind_logger())
      {
         dm_logger->on_end_transaction();
      }
   }

Here is the call graph for this function:

Member Function Documentation

add_net_usage()

void sysio::chain::transaction_context::add_net_usage ( uint64_t u )

inline

Definition at line 57 of file transaction_context.hpp.

{ net_usage += u; check_net_usage(); }

Here is the call graph for this function:

Here is the caller graph for this function:

check_net_usage()

void sysio::chain::transaction_context::check_net_usage

(

)

const

Definition at line 404 of file transaction_context.cpp.

                                                  {
      if (!control.skip_trx_checks()) {
         if( BOOST_UNLIKELY(net_usage > eager_net_limit) ) {
            if ( net_limit_due_to_block ) {
               SYS_THROW( block_net_usage_exceeded,
                          "not enough space left in block: ${net_usage} > ${net_limit}",
                          ("net_usage", net_usage)("net_limit", eager_net_limit) );
            }  else if (net_limit_due_to_greylist) {
               SYS_THROW( greylist_net_usage_exceeded,
                          "greylisted transaction net usage is too high: ${net_usage} > ${net_limit}",
                          ("net_usage", net_usage)("net_limit", eager_net_limit) );
            } else {
               SYS_THROW( tx_net_usage_exceeded,
                          "transaction net usage is too high: ${net_usage} > ${net_limit}",
                          ("net_usage", net_usage)("net_limit", eager_net_limit) );
            }
         }
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

checktime()

void sysio::chain::transaction_context::checktime

(

)

const

Definition at line 424 of file transaction_context.cpp.

                                            {
      if(BOOST_LIKELY(transaction_timer.expired == false))
         return;
 
      auto now = fc::time_point::now();
      if( explicit_billed_cpu_time || deadline_exception_code == deadline_exception::code_value ) {
         SYS_THROW( deadline_exception, "deadline exceeded ${billing_timer}us",
                     ("billing_timer", now - pseudo_start)("now", now)("deadline", _deadline)("start", start) );
      } else if( deadline_exception_code == block_cpu_usage_exceeded::code_value ) {
         SYS_THROW( block_cpu_usage_exceeded,
                     "not enough time left in block to complete executing transaction ${billing_timer}us",
                     ("now", now)("deadline", _deadline)("start", start)("billing_timer", now - pseudo_start) );
      } else if( deadline_exception_code == tx_cpu_usage_exceeded::code_value ) {
         if (cpu_limit_due_to_greylist) {
            SYS_THROW( greylist_cpu_usage_exceeded,
                     "greylisted transaction was executing for too long ${billing_timer}us",
                     ("now", now)("deadline", _deadline)("start", start)("billing_timer", now - pseudo_start) );
         } else {
            SYS_THROW( tx_cpu_usage_exceeded,
                     "transaction was executing for too long ${billing_timer}us",
                     ("now", now)("deadline", _deadline)("start", start)("billing_timer", now - pseudo_start) );
         }
      } else if( deadline_exception_code == leeway_deadline_exception::code_value ) {
         SYS_THROW( leeway_deadline_exception,
                     "the transaction was unable to complete by deadline, "
                     "but it is possible it could have succeeded if it were allowed to run to completion ${billing_timer}",
                     ("now", now)("deadline", _deadline)("start", start)("billing_timer", now - pseudo_start) );
      }
      SYS_ASSERT( false,  transaction_exception, "unexpected deadline exception code ${code}", ("code", deadline_exception_code) );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

exec()

void sysio::chain::transaction_context::exec

(

)

Definition at line 313 of file transaction_context.cpp.

                                  {
      SYS_ASSERT( is_initialized, transaction_exception, "must first initialize" );
 
      const transaction& trx = packed_trx.get_transaction();
      if( apply_context_free ) {
         for( const auto& act : trx.context_free_actions ) {
            schedule_action( act, act.account, true, 0, 0 );
         }
      }
 
      if( delay == fc::microseconds() ) {
         for( const auto& act : trx.actions ) {
            schedule_action( act, act.account, false, 0, 0 );
         }
      }
 
      auto& action_traces = trace->action_traces;
      uint32_t num_original_actions_to_execute = action_traces.size();
      for( uint32_t i = 1; i <= num_original_actions_to_execute; ++i ) {
         execute_action( i, 0 );
      }
 
      if( delay != fc::microseconds() ) {
         schedule_transaction();
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

finalize()

void sysio::chain::transaction_context::finalize

(

)

Definition at line 340 of file transaction_context.cpp.

                                      {
      SYS_ASSERT( is_initialized, transaction_exception, "must first initialize" );
 
      if( is_input ) {
         const transaction& trx = packed_trx.get_transaction();
         auto& am = control.get_mutable_authorization_manager();
         for( const auto& act : trx.actions ) {
            for( const auto& auth : act.authorization ) {
               am.update_permission_usage( am.get_permission(auth) );
            }
         }
      }
 
      // auto& rl = control.get_mutable_resource_limits_manager();
      // for( auto a : validate_ram_usage ) {
      //    rl.verify_account_ram_usage( a );
      // }
 
      // // Calculate the new highest network usage and CPU time that all of the billed accounts can afford to be billed
      // int64_t account_net_limit = 0;
      // int64_t account_cpu_limit = 0;
      // bool greylisted_net = false, greylisted_cpu = false;
      // std::tie( account_net_limit, account_cpu_limit, greylisted_net, greylisted_cpu) = max_bandwidth_billed_accounts_can_pay();
      // net_limit_due_to_greylist |= greylisted_net;
      // cpu_limit_due_to_greylist |= greylisted_cpu;
 
      // // Possibly lower net_limit to what the billed accounts can pay
      // if( static_cast<uint64_t>(account_net_limit) <= net_limit ) {
      //    // NOTE: net_limit may possibly not be objective anymore due to net greylisting, but it should still be no greater than the truly objective net_limit
      //    net_limit = static_cast<uint64_t>(account_net_limit);
      //    net_limit_due_to_block = false;
      // }
 
      // // Possibly lower objective_duration_limit to what the billed accounts can pay
      // if( account_cpu_limit <= objective_duration_limit.count() ) {
      //    // NOTE: objective_duration_limit may possibly not be objective anymore due to cpu greylisting, but it should still be no greater than the truly objective objective_duration_limit
      //    objective_duration_limit = fc::microseconds(account_cpu_limit);
      //    billing_timer_exception_code = tx_cpu_usage_exceeded::code_value;
      // }
 
      net_usage = ((net_usage + 7)/8)*8; // Round up to nearest multiple of word size (8 bytes)
 
      eager_net_limit = net_limit;
      check_net_usage();
 
      auto now = fc::time_point::now();
      trace->elapsed = now - start;
 
      update_billed_cpu_time( now );
 
      // validate_cpu_usage_to_bill( billed_cpu_time_us, account_cpu_limit, true );
      // auto& rl = control.get_mutable_resource_limits_manager();
      // rl.add_transaction_usage( bill_to_accounts, static_cast<uint64_t>(billed_cpu_time_us), net_usage,
      //                           block_timestamp_type(control.pending_block_time()).slot ); // Should never fail
   }

Here is the call graph for this function:

Here is the caller graph for this function:

hash_with_checktime()

template<typename DigestType >

DigestType sysio::chain::transaction_context::hash_with_checktime ( const char * data, uint32_t datalen ) const

inline

Definition at line 64 of file transaction_context.hpp.

                                                                                          {
            const size_t bs = sysio::chain::config::hashing_checktime_block_size;
            typename DigestType::encoder enc;
            while ( datalen > bs ) {
               enc.write( data, bs );
               data    += bs;
               datalen -= bs;
               checktime();
            }
            enc.write( data, datalen );
            return enc.result();
         }

Here is the call graph for this function:

Here is the caller graph for this function:

init_for_deferred_trx()

void sysio::chain::transaction_context::init_for_deferred_trx

(

fc::time_point

published

)

Definition at line 296 of file transaction_context.cpp.

   {
      const transaction& trx = packed_trx.get_transaction();
      if( (trx.expiration.sec_since_epoch() != 0) && (trx.transaction_extensions.size() > 0) ) {
         disallow_transaction_extensions( "no transaction extensions supported yet for deferred transactions" );
      }
      // If (trx.expiration.sec_since_epoch() == 0) then it was created after NO_DUPLICATE_DEFERRED_ID activation,
      // and so validation of its extensions was done either in:
      //   * apply_context::schedule_deferred_transaction for contract-generated transactions;
      //   * or transaction_context::init_for_input_trx for delayed input transactions.
 
      published = p;
      trace->scheduled = true;
      apply_context_free = false;
      init( 0 );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

init_for_implicit_trx()

void sysio::chain::transaction_context::init_for_implicit_trx

(

uint64_t

initial_net_usage = 0

)

Definition at line 244 of file transaction_context.cpp.

   {
      const transaction& trx = packed_trx.get_transaction();
      if( trx.transaction_extensions.size() > 0 ) {
         disallow_transaction_extensions( "no transaction extensions supported yet for implicit transactions" );
      }
 
      published = control.pending_block_time();
      init( initial_net_usage);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

init_for_input_trx()

void sysio::chain::transaction_context::init_for_input_trx	(	uint64_t	packed_trx_unprunable_size,
		uint64_t	packed_trx_prunable_size )

checks for dupes

Definition at line 255 of file transaction_context.cpp.

   {
      const transaction& trx = packed_trx.get_transaction();
      if( trx.transaction_extensions.size() > 0 ) {
         disallow_transaction_extensions( "no transaction extensions supported yet for input transactions" );
      }
 
      const auto& cfg = control.get_global_properties().configuration;
 
      uint64_t discounted_size_for_pruned_data = packed_trx_prunable_size;
      if( cfg.context_free_discount_net_usage_den > 0
          && cfg.context_free_discount_net_usage_num < cfg.context_free_discount_net_usage_den )
      {
         discounted_size_for_pruned_data *= cfg.context_free_discount_net_usage_num;
         discounted_size_for_pruned_data =  ( discounted_size_for_pruned_data + cfg.context_free_discount_net_usage_den - 1)
                                                                                    / cfg.context_free_discount_net_usage_den; // rounds up
      }
 
      uint64_t initial_net_usage = static_cast<uint64_t>(cfg.base_per_transaction_net_usage)
                                    + packed_trx_unprunable_size + discounted_size_for_pruned_data;
 
 
      if( trx.delay_sec.value > 0 ) {
          // If delayed, also charge ahead of time for the additional net usage needed to retire the delayed transaction
          // whether that be by successfully executing, soft failure, hard failure, or expiration.
         initial_net_usage += static_cast<uint64_t>(cfg.base_per_transaction_net_usage)
                               + static_cast<uint64_t>(config::transaction_id_net_usage);
      }
 
      published = control.pending_block_time();
      is_input = true;
      if (!control.skip_trx_checks()) {
         control.validate_expiration(trx);
         control.validate_tapos(trx);
         validate_referenced_accounts( trx, enforce_whiteblacklist && control.is_producing_block() );
      }
      init( initial_net_usage);
      record_transaction( packed_trx.id(), trx.expiration ); 
   }

Here is the call graph for this function:

Here is the caller graph for this function:

max_bandwidth_billed_accounts_can_pay()

std::tuple< int64_t, int64_t, bool, bool > sysio::chain::transaction_context::max_bandwidth_billed_accounts_can_pay

(

bool

force_elastic_limits = false

)

const

Definition at line 574 of file transaction_context.cpp.

                                                                                                                                     {
      // Assumes rl.update_account_usage( bill_to_accounts, block_timestamp_type(control.pending_block_time()).slot ) was already called prior
 
      // Calculate the new highest network usage and CPU time that all of the billed accounts can afford to be billed
      auto& rl = control.get_mutable_resource_limits_manager();
      const static int64_t large_number_no_overflow = std::numeric_limits<int64_t>::max()/2;
      int64_t account_net_limit = large_number_no_overflow;
      int64_t account_cpu_limit = large_number_no_overflow;
      bool greylisted_net = false;
      bool greylisted_cpu = false;
 
      uint32_t specified_greylist_limit = control.get_greylist_limit();
      for( const auto& a : bill_to_accounts ) {
         uint32_t greylist_limit = config::maximum_elastic_resource_multiplier;
         if( !force_elastic_limits && control.is_producing_block() ) {
            if( control.is_resource_greylisted(a) ) {
               greylist_limit = 1;
            } else {
               greylist_limit = specified_greylist_limit;
            }
         }
         auto [net_limit, net_was_greylisted] = rl.get_account_net_limit(a, greylist_limit);
         if( net_limit >= 0 ) {
            account_net_limit = std::min( account_net_limit, net_limit );
            greylisted_net |= net_was_greylisted;
         }
         auto [cpu_limit, cpu_was_greylisted] = rl.get_account_cpu_limit(a, greylist_limit);
         if( cpu_limit >= 0 ) {
            account_cpu_limit = std::min( account_cpu_limit, cpu_limit );
            greylisted_cpu |= cpu_was_greylisted;
         }
      }
 
      SYS_ASSERT( (!force_elastic_limits && control.is_producing_block()) || (!greylisted_cpu && !greylisted_net),
                  transaction_exception, "greylisted when not producing block" );
 
      return std::make_tuple(account_net_limit, account_cpu_limit, greylisted_net, greylisted_cpu);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

pause_billing_timer()

void sysio::chain::transaction_context::pause_billing_timer

(

)

Definition at line 455 of file transaction_context.cpp.

                                                 {
      if( explicit_billed_cpu_time || pseudo_start == fc::time_point() ) return; // either irrelevant or already paused
 
      paused_time = fc::time_point::now();
      billed_time = paused_time - pseudo_start;
      pseudo_start = fc::time_point();
      transaction_timer.stop();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

resume_billing_timer()

void sysio::chain::transaction_context::resume_billing_timer

(

)

Definition at line 464 of file transaction_context.cpp.

                                                  {
      if( explicit_billed_cpu_time || pseudo_start != fc::time_point() ) return; // either irrelevant or already running
 
      auto now = fc::time_point::now();
      auto paused = now - paused_time;
 
      pseudo_start = now - billed_time;
      _deadline += paused;
 
      // do not allow to go past block wall clock deadline
      if( block_deadline < _deadline ) {
         deadline_exception_code = deadline_exception::code_value;
         _deadline = block_deadline;
      }
 
      transaction_timer.start(_deadline);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

squash()

void sysio::chain::transaction_context::squash

(

)

Definition at line 396 of file transaction_context.cpp.

                                    {
      if (undo_session) undo_session->squash();
   }

Here is the caller graph for this function:

undo()

void sysio::chain::transaction_context::undo

(

)

Definition at line 400 of file transaction_context.cpp.

                                  {
      if (undo_session) undo_session->undo();
   }

Here is the caller graph for this function:

update_billed_cpu_time()

uint32_t sysio::chain::transaction_context::update_billed_cpu_time

(

fc::time_point

now

)

Definition at line 565 of file transaction_context.cpp.

                                                                          {
      if( explicit_billed_cpu_time ) return static_cast<uint32_t>(billed_cpu_time_us);
 
      const auto& cfg = control.get_global_properties().configuration;
      billed_cpu_time_us = std::max( (now - pseudo_start).count(), static_cast<int64_t>(cfg.min_transaction_cpu_usage) );
 
      return static_cast<uint32_t>(billed_cpu_time_us);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

validate_referenced_accounts()

void sysio::chain::transaction_context::validate_referenced_accounts	(	const transaction &	trx,
		bool	enforce_actor_whitelist_blacklist ) const

Definition at line 739 of file transaction_context.cpp.

                                                                                                                               {
      const auto& db = control.db();
      const auto& auth_manager = control.get_authorization_manager();
 
      for( const auto& a : trx.context_free_actions ) {
         auto* code = db.find<account_object, by_name>(a.account);
         SYS_ASSERT( code != nullptr, transaction_exception,
                     "action's code account '${account}' does not exist", ("account", a.account) );
         SYS_ASSERT( a.authorization.size() == 0, transaction_exception,
                     "context-free actions cannot have authorizations" );
      }
 
      flat_set<account_name> actors;
 
      bool one_auth = false;
      for( const auto& a : trx.actions ) {
         auto* code = db.find<account_object, by_name>(a.account);
         SYS_ASSERT( code != nullptr, transaction_exception,
                     "action's code account '${account}' does not exist", ("account", a.account) );
         for( const auto& auth : a.authorization ) {
            one_auth = true;
            auto* actor = db.find<account_object, by_name>(auth.actor);
            SYS_ASSERT( actor  != nullptr, transaction_exception,
                        "action's authorizing actor '${account}' does not exist", ("account", auth.actor) );
            SYS_ASSERT( auth_manager.find_permission(auth) != nullptr, transaction_exception,
                        "action's authorizations include a non-existent permission: ${permission}",
                        ("permission", auth) );
            if( enforce_actor_whitelist_blacklist )
               actors.insert( auth.actor );
         }
      }
      SYS_ASSERT( one_auth || is_read_only, tx_no_auths, "transaction must have at least one authorization" );
 
      if( enforce_actor_whitelist_blacklist ) {
         control.check_actor_list( actors );
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

apply_context

friend class apply_context

friend

Definition at line 89 of file transaction_context.hpp.

controller_impl

friend struct controller_impl

friend

Definition at line 88 of file transaction_context.hpp.

Member Data Documentation

apply_context_free

bool sysio::chain::transaction_context::apply_context_free = true

Definition at line 140 of file transaction_context.hpp.

bill_to_accounts

flat_set<account_name> sysio::chain::transaction_context::bill_to_accounts

Definition at line 132 of file transaction_context.hpp.

billed_cpu_time_us

int64_t sysio::chain::transaction_context::billed_cpu_time_us = 0

Definition at line 145 of file transaction_context.hpp.

block_deadline

fc::time_point sysio::chain::transaction_context::block_deadline = fc::time_point::maximum()

Definition at line 143 of file transaction_context.hpp.

control

controller& sysio::chain::transaction_context::control

Definition at line 122 of file transaction_context.hpp.

delay

fc::microseconds sysio::chain::transaction_context::delay

Definition at line 138 of file transaction_context.hpp.

enforce_whiteblacklist

bool sysio::chain::transaction_context::enforce_whiteblacklist = true

Definition at line 141 of file transaction_context.hpp.

executed_action_receipt_digests

vector<digest_type> sysio::chain::transaction_context::executed_action_receipt_digests

Definition at line 131 of file transaction_context.hpp.

explicit_billed_cpu_time

bool sysio::chain::transaction_context::explicit_billed_cpu_time = false

Definition at line 147 of file transaction_context.hpp.

initial_max_billable_cpu

uint64_t sysio::chain::transaction_context::initial_max_billable_cpu = 0

Definition at line 136 of file transaction_context.hpp.

is_input

bool sysio::chain::transaction_context::is_input = false

Definition at line 139 of file transaction_context.hpp.

is_read_only

const bool sysio::chain::transaction_context::is_read_only

Definition at line 151 of file transaction_context.hpp.

leeway

fc::microseconds sysio::chain::transaction_context::leeway = fc::microseconds( config::default_subjective_cpu_leeway_us )

Definition at line 144 of file transaction_context.hpp.

packed_trx

const packed_transaction& sysio::chain::transaction_context::packed_trx

Definition at line 123 of file transaction_context.hpp.

published

fc::time_point sysio::chain::transaction_context::published

Definition at line 128 of file transaction_context.hpp.

start

fc::time_point sysio::chain::transaction_context::start

Definition at line 126 of file transaction_context.hpp.

subjective_cpu_bill_us

int64_t sysio::chain::transaction_context::subjective_cpu_bill_us = 0

Definition at line 146 of file transaction_context.hpp.

trace

transaction_trace_ptr sysio::chain::transaction_context::trace

Definition at line 125 of file transaction_context.hpp.

transaction_timer

transaction_checktime_timer sysio::chain::transaction_context::transaction_timer

Definition at line 149 of file transaction_context.hpp.

undo_session

std::optional<chainbase::database::session> sysio::chain::transaction_context::undo_session

Definition at line 124 of file transaction_context.hpp.

validate_ram_usage

flat_set<account_name> sysio::chain::transaction_context::validate_ram_usage

Definition at line 133 of file transaction_context.hpp.

---

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

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