sysio::chain_apis::read_write Class Reference

#include <chain_plugin.hpp>

Classes
struct	push_transaction_results
struct	send_transaction2_params

Public Types
using	push_block_params = chain::signed_block
using	push_block_results = empty
using	push_transaction_params = fc::variant_object
using	push_transactions_params = vector<push_transaction_params>
using	push_transactions_results = vector<push_transaction_results>
using	send_transaction_params = push_transaction_params
using	send_transaction_results = push_transaction_results

Public Member Functions
	read_write (controller &db, std::optional< trx_retry_db > &trx_retry, const fc::microseconds &abi_serializer_max_time, bool api_accept_transactions)
void	validate () const
void	push_block (push_block_params &&params, chain::plugin_interface::next_function< push_block_results > next)
void	push_transaction (const push_transaction_params &params, chain::plugin_interface::next_function< push_transaction_results > next)
void	push_transactions (const push_transactions_params &params, chain::plugin_interface::next_function< push_transactions_results > next)
void	send_transaction (const send_transaction_params &params, chain::plugin_interface::next_function< send_transaction_results > next)
void	send_transaction2 (const send_transaction2_params &params, chain::plugin_interface::next_function< send_transaction_results > next)

Detailed Description

Definition at line 653 of file chain_plugin.hpp.

Member Typedef Documentation

push_block_params

using sysio::chain_apis::read_write::push_block_params = chain::signed_block

Definition at line 662 of file chain_plugin.hpp.

push_block_results

using sysio::chain_apis::read_write::push_block_results = empty

Definition at line 663 of file chain_plugin.hpp.

push_transaction_params

using sysio::chain_apis::read_write::push_transaction_params = fc::variant_object

Definition at line 666 of file chain_plugin.hpp.

push_transactions_params

using sysio::chain_apis::read_write::push_transactions_params = vector<push_transaction_params>

Definition at line 674 of file chain_plugin.hpp.

push_transactions_results

using sysio::chain_apis::read_write::push_transactions_results = vector<push_transaction_results>

Definition at line 675 of file chain_plugin.hpp.

send_transaction_params

using sysio::chain_apis::read_write::send_transaction_params = push_transaction_params

Definition at line 678 of file chain_plugin.hpp.

send_transaction_results

using sysio::chain_apis::read_write::send_transaction_results = push_transaction_results

Definition at line 679 of file chain_plugin.hpp.

Constructor & Destructor Documentation

read_write()

sysio::chain_apis::read_write::read_write	(	controller &	db,
		std::optional< trx_retry_db > &	trx_retry,
		const fc::microseconds &	abi_serializer_max_time,
		bool	api_accept_transactions )

Definition at line 1312 of file chain_plugin.cpp.

: db(db)
, trx_retry(trx_retry)
, abi_serializer_max_time(abi_serializer_max_time)
, api_accept_transactions(api_accept_transactions)
{
}

Member Function Documentation

push_block()

void sysio::chain_apis::read_write::push_block	(	push_block_params &&	params,
		chain::plugin_interface::next_function< push_block_results >	next )

Definition at line 2129 of file chain_plugin.cpp.

                                                                                                                  {
   try {
      app().get_method<incoming::methods::block_sync>()(std::make_shared<signed_block>( std::move(params) ), std::optional<block_id_type>{}, block_state_ptr{});
   } catch ( boost::interprocess::bad_alloc& ) {
      chain_plugin::handle_db_exhaustion();
   } catch ( const std::bad_alloc& ) {
      chain_plugin::handle_bad_alloc();
   } FC_LOG_AND_DROP()
   next(read_write::push_block_results{});
}

Here is the call graph for this function:

push_transaction()

void sysio::chain_apis::read_write::push_transaction	(	const push_transaction_params &	params,
		chain::plugin_interface::next_function< push_transaction_results >	next )

Definition at line 2140 of file chain_plugin.cpp.

                                                                                                                                         {
   try {
      auto pretty_input = std::make_shared<packed_transaction>();
      auto resolver = make_resolver(db, abi_serializer::create_yield_function( abi_serializer_max_time ));
      try {
         abi_serializer::from_variant(params, *pretty_input, std::move( resolver ), abi_serializer::create_yield_function( abi_serializer_max_time ));
      } SYS_RETHROW_EXCEPTIONS(chain::packed_transaction_type_exception, "Invalid packed transaction")
 
      app().get_method<incoming::methods::transaction_async>()(pretty_input, true, false, false,
            [this, next](const std::variant<fc::exception_ptr, transaction_trace_ptr>& result) -> void {
         if (std::holds_alternative<fc::exception_ptr>(result)) {
            next(std::get<fc::exception_ptr>(result));
         } else {
            auto trx_trace_ptr = std::get<transaction_trace_ptr>(result);
 
            try {
               fc::variant output;
               try {
                  output = db.to_variant_with_abi( *trx_trace_ptr, abi_serializer::create_yield_function( abi_serializer_max_time ) );
 
                  // Create map of (closest_unnotified_ancestor_action_ordinal, global_sequence) with action trace
                  std::map< std::pair<uint32_t, uint64_t>, fc::mutable_variant_object > act_traces_map;
                  for( const auto& act_trace : output["action_traces"].get_array() ) {
                     if (act_trace["receipt"].is_null() && act_trace["except"].is_null()) continue;
                     auto closest_unnotified_ancestor_action_ordinal =
                           act_trace["closest_unnotified_ancestor_action_ordinal"].as<fc::unsigned_int>().value;
                     auto global_sequence = act_trace["receipt"].is_null() ?
                                                std::numeric_limits<uint64_t>::max() :
                                                act_trace["receipt"]["global_sequence"].as<uint64_t>();
                     act_traces_map.emplace( std::make_pair( closest_unnotified_ancestor_action_ordinal,
                                                             global_sequence ),
                                             act_trace.get_object() );
                  }
 
                  std::function<vector<fc::variant>(uint32_t)> convert_act_trace_to_tree_struct =
                  [&](uint32_t closest_unnotified_ancestor_action_ordinal) {
                     vector<fc::variant> restructured_act_traces;
                     auto it = act_traces_map.lower_bound(
                                 std::make_pair( closest_unnotified_ancestor_action_ordinal, 0)
                     );
                     for( ;
                        it != act_traces_map.end() && it->first.first == closest_unnotified_ancestor_action_ordinal; ++it )
                     {
                        auto& act_trace_mvo = it->second;
 
                        auto action_ordinal = act_trace_mvo["action_ordinal"].as<fc::unsigned_int>().value;
                        act_trace_mvo["inline_traces"] = convert_act_trace_to_tree_struct(action_ordinal);
                        if (act_trace_mvo["receipt"].is_null()) {
                           act_trace_mvo["receipt"] = fc::mutable_variant_object()
                              ("abi_sequence", 0)
                              ("act_digest", digest_type::hash(trx_trace_ptr->action_traces[action_ordinal-1].act))
                              ("auth_sequence", flat_map<account_name,uint64_t>())
                              ("code_sequence", 0)
                              ("global_sequence", 0)
                              ("receiver", act_trace_mvo["receiver"])
                              ("recv_sequence", 0);
                        }
                        restructured_act_traces.push_back( std::move(act_trace_mvo) );
                     }
                     return restructured_act_traces;
                  };
 
                  fc::mutable_variant_object output_mvo(output);
                  output_mvo["action_traces"] = convert_act_trace_to_tree_struct(0);
 
                  output = output_mvo;
               } catch( chain::abi_exception& ) {
                  output = *trx_trace_ptr;
               }
 
               const chain::transaction_id_type& id = trx_trace_ptr->id;
               next(read_write::push_transaction_results{id, output});
            } CATCH_AND_CALL(next);
         }
      });
   } catch ( boost::interprocess::bad_alloc& ) {
      chain_plugin::handle_db_exhaustion();
   } catch ( const std::bad_alloc& ) {
      chain_plugin::handle_bad_alloc();
   } CATCH_AND_CALL(next);
}

Here is the call graph for this function:

push_transactions()

void sysio::chain_apis::read_write::push_transactions	(	const push_transactions_params &	params,
		chain::plugin_interface::next_function< push_transactions_results >	next )

Definition at line 2243 of file chain_plugin.cpp.

                                                                                                                                            {
   try {
      SYS_ASSERT( params.size() <= 1000, too_many_tx_at_once, "Attempt to push too many transactions at once" );
      auto params_copy = std::make_shared<read_write::push_transactions_params>(params.begin(), params.end());
      auto result = std::make_shared<read_write::push_transactions_results>();
      result->reserve(params.size());
 
      push_recurse(this, 0, params_copy, result, next);
   } catch ( boost::interprocess::bad_alloc& ) {
      chain_plugin::handle_db_exhaustion();
   } catch ( const std::bad_alloc& ) {
      chain_plugin::handle_bad_alloc();
   } CATCH_AND_CALL(next);
}

Here is the call graph for this function:

send_transaction()

void sysio::chain_apis::read_write::send_transaction	(	const send_transaction_params &	params,
		chain::plugin_interface::next_function< send_transaction_results >	next )

Definition at line 2258 of file chain_plugin.cpp.

                                                                                                                                         {
 
   try {
      auto pretty_input = std::make_shared<packed_transaction>();
      auto resolver = make_resolver(db, abi_serializer::create_yield_function( abi_serializer_max_time ));
      try {
         abi_serializer::from_variant(params, *pretty_input, resolver, abi_serializer::create_yield_function( abi_serializer_max_time ));
      } SYS_RETHROW_EXCEPTIONS(chain::packed_transaction_type_exception, "Invalid packed transaction")
 
      app().get_method<incoming::methods::transaction_async>()(pretty_input, true, false, false,
            [this, next](const std::variant<fc::exception_ptr, transaction_trace_ptr>& result) -> void {
         if (std::holds_alternative<fc::exception_ptr>(result)) {
            next(std::get<fc::exception_ptr>(result));
         } else {
            auto trx_trace_ptr = std::get<transaction_trace_ptr>(result);
 
            try {
               fc::variant output;
               try {
                  output = db.to_variant_with_abi( *trx_trace_ptr, abi_serializer::create_yield_function( abi_serializer_max_time ) );
               } catch( chain::abi_exception& ) {
                  output = *trx_trace_ptr;
               }
 
               const chain::transaction_id_type& id = trx_trace_ptr->id;
               next(read_write::send_transaction_results{id, output});
            } CATCH_AND_CALL(next);
         }
      });
   } catch ( boost::interprocess::bad_alloc& ) {
      chain_plugin::handle_db_exhaustion();
   } catch ( const std::bad_alloc& ) {
      chain_plugin::handle_bad_alloc();
   } CATCH_AND_CALL(next);
}

Here is the call graph for this function:

send_transaction2()

void sysio::chain_apis::read_write::send_transaction2	(	const send_transaction2_params &	params,
		chain::plugin_interface::next_function< send_transaction_results >	next )

Definition at line 2294 of file chain_plugin.cpp.

                                                                                                                                           {
   try {
      auto ptrx = std::make_shared<packed_transaction>();
      auto resolver = make_resolver(db, abi_serializer::create_yield_function( abi_serializer_max_time ));
      try {
         abi_serializer::from_variant(params.transaction, *ptrx, resolver, abi_serializer::create_yield_function( abi_serializer_max_time ));
      } SYS_RETHROW_EXCEPTIONS(chain::packed_transaction_type_exception, "Invalid packed transaction")
 
      bool retry = params.retry_trx;
      std::optional<uint16_t> retry_num_blocks = params.retry_trx_num_blocks;
 
      SYS_ASSERT( !retry || trx_retry.has_value(), unsupported_feature, "Transaction retry not enabled on node" );
      SYS_ASSERT( !retry || (ptrx->expiration() <= trx_retry->get_max_expiration_time()), tx_exp_too_far_exception,
                  "retry transaction expiration ${e} larger than allowed ${m}",
                  ("e", ptrx->expiration())("m", trx_retry->get_max_expiration_time()) );
 
      app().get_method<incoming::methods::transaction_async>()(ptrx, true, false, static_cast<bool>(params.return_failure_trace),
         [this, ptrx, next, retry, retry_num_blocks](const std::variant<fc::exception_ptr, transaction_trace_ptr>& result) -> void {
            if( std::holds_alternative<fc::exception_ptr>( result ) ) {
               next( std::get<fc::exception_ptr>( result ) );
            } else {
               try {
                  auto trx_trace_ptr = std::get<transaction_trace_ptr>( result );
                  if( retry && trx_retry.has_value() && !trx_trace_ptr->except) {
                     // will be ack'ed via next later
                     trx_retry->track_transaction( ptrx, retry_num_blocks,
                        [ptrx, next](const std::variant<fc::exception_ptr, std::unique_ptr<fc::variant>>& result ) {
                           if( std::holds_alternative<fc::exception_ptr>( result ) ) {
                              next( std::get<fc::exception_ptr>( result ) );
                           } else {
                              fc::variant& output = *std::get<std::unique_ptr<fc::variant>>( result );
                              next( read_write::send_transaction_results{ptrx->id(), std::move( output )} );
                           }
                        } );
                  } else {
                     fc::variant output;
                     try {
                        output = db.to_variant_with_abi( *trx_trace_ptr, abi_serializer::create_yield_function( abi_serializer_max_time ) );
                     } catch( chain::abi_exception& ) {
                        output = *trx_trace_ptr;
                     }
                     const chain::transaction_id_type& id = trx_trace_ptr->id;
                     next( read_write::send_transaction_results{id, std::move( output )} );
                  }
               } CATCH_AND_CALL( next );
            }
         });
   } catch ( boost::interprocess::bad_alloc& ) {
      chain_plugin::handle_db_exhaustion();
   } catch ( const std::bad_alloc& ) {
      chain_plugin::handle_bad_alloc();
   } CATCH_AND_CALL(next);
}

Here is the call graph for this function:

validate()

void sysio::chain_apis::read_write::validate

(

)

const

Definition at line 1320 of file chain_plugin.cpp.

                                          {
   SYS_ASSERT( api_accept_transactions, missing_chain_api_plugin_exception,
               "Not allowed, node has api-accept-transactions = false" );
}

---

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

• plugins/chain_plugin/include/sysio/chain_plugin/chain_plugin.hpp
• plugins/chain_plugin/chain_plugin.cpp