sysio::chain_apis::read_only Class Reference

#include <chain_plugin.hpp>

Classes
struct	abi_bin_to_json_params
struct	abi_bin_to_json_result
struct	abi_json_to_bin_params
struct	abi_json_to_bin_result
struct	compute_transaction_params
struct	compute_transaction_results
struct	get_abi_params
struct	get_abi_results
struct	get_account_params
struct	get_account_results
struct	get_activated_protocol_features_params
struct	get_activated_protocol_features_results
struct	get_block_header_state_params
struct	get_block_info_params
struct	get_block_params
struct	get_code_hash_params
struct	get_code_hash_results
struct	get_code_params
struct	get_code_results
struct	get_currency_balance_params
struct	get_currency_stats_params
struct	get_currency_stats_result
struct	get_info_results
struct	get_producer_schedule_params
struct	get_producer_schedule_result
struct	get_producers_params
struct	get_producers_result
struct	get_raw_abi_params
struct	get_raw_abi_results
struct	get_raw_code_and_abi_params
struct	get_raw_code_and_abi_results
struct	get_required_keys_params
struct	get_required_keys_result
struct	get_scheduled_transactions_params
struct	get_scheduled_transactions_result
struct	get_table_by_scope_params
struct	get_table_by_scope_result
struct	get_table_by_scope_result_row
struct	get_table_rows_params
struct	get_table_rows_result
struct	get_transaction_status_params
struct	get_transaction_status_results
struct	producer_info

Public Types
using	get_info_params = empty
using	account_resource_limit = chain::resource_limits::account_resource_limit
using	get_transaction_id_params = transaction
using	get_transaction_id_result = transaction_id_type
using	get_accounts_by_authorizers_result = account_query_db::get_accounts_by_authorizers_result
using	get_accounts_by_authorizers_params = account_query_db::get_accounts_by_authorizers_params

Public Member Functions
	read_only (const controller &db, const std::optional< account_query_db > &aqdb, const fc::microseconds &abi_serializer_max_time, const producer_plugin *producer_plug, const trx_finality_status_processing *trx_finality_status_proc)
void	validate () const
void	set_shorten_abi_errors (bool f)
get_info_results	get_info (const get_info_params &) const
get_transaction_status_results	get_transaction_status (const get_transaction_status_params &params) const
get_activated_protocol_features_results	get_activated_protocol_features (const get_activated_protocol_features_params &params) const
get_account_results	get_account (const get_account_params &params) const
get_code_results	get_code (const get_code_params &params) const
get_code_hash_results	get_code_hash (const get_code_hash_params &params) const
get_abi_results	get_abi (const get_abi_params &params) const
get_raw_code_and_abi_results	get_raw_code_and_abi (const get_raw_code_and_abi_params &params) const
get_raw_abi_results	get_raw_abi (const get_raw_abi_params &params) const
abi_json_to_bin_result	abi_json_to_bin (const abi_json_to_bin_params &params) const
abi_bin_to_json_result	abi_bin_to_json (const abi_bin_to_json_params &params) const
get_required_keys_result	get_required_keys (const get_required_keys_params &params) const
get_transaction_id_result	get_transaction_id (const get_transaction_id_params &params) const
fc::variant	get_block (const get_block_params &params) const
fc::variant	get_block_info (const get_block_info_params &params) const
fc::variant	get_block_header_state (const get_block_header_state_params &params) const
get_table_rows_result	get_table_rows (const get_table_rows_params &params) const
get_table_by_scope_result	get_table_by_scope (const get_table_by_scope_params &params) const
vector< asset >	get_currency_balance (const get_currency_balance_params &params) const
fc::variant	get_currency_stats (const get_currency_stats_params &params) const
get_producers_result	get_producers (const get_producers_params &params) const
get_producer_schedule_result	get_producer_schedule (const get_producer_schedule_params &params) const
get_scheduled_transactions_result	get_scheduled_transactions (const get_scheduled_transactions_params &params) const
void	compute_transaction (const compute_transaction_params &params, chain::plugin_interface::next_function< compute_transaction_results > next) const
template<typename Function >
void	walk_key_value_table (const name &code, const name &scope, const name &table, Function f) const
template<typename IndexType , typename SecKeyType , typename ConvFn >
read_only::get_table_rows_result	get_table_rows_by_seckey (const read_only::get_table_rows_params &p, const abi_def &abi, ConvFn conv) const
template<typename IndexType >
read_only::get_table_rows_result	get_table_rows_ex (const read_only::get_table_rows_params &p, const abi_def &abi) const
get_accounts_by_authorizers_result	get_accounts_by_authorizers (const get_accounts_by_authorizers_params &args) const
chain::symbol	extract_core_symbol () const

Static Public Member Functions
static void	copy_inline_row (const chain::key_value_object &obj, vector< char > &data)
static uint64_t	get_table_index_name (const read_only::get_table_rows_params &p, bool &primary)

Static Public Attributes
static const string	KEYi64 = "i64"

Detailed Description

Definition at line 88 of file chain_plugin.hpp.

Member Typedef Documentation

account_resource_limit

using sysio::chain_apis::read_only::account_resource_limit = chain::resource_limits::account_resource_limit

Definition at line 178 of file chain_plugin.hpp.

get_accounts_by_authorizers_params

using sysio::chain_apis::read_only::get_accounts_by_authorizers_params = account_query_db::get_accounts_by_authorizers_params

Definition at line 646 of file chain_plugin.hpp.

get_accounts_by_authorizers_result

using sysio::chain_apis::read_only::get_accounts_by_authorizers_result = account_query_db::get_accounts_by_authorizers_result

Definition at line 645 of file chain_plugin.hpp.

get_info_params

using sysio::chain_apis::read_only::get_info_params = empty

Definition at line 107 of file chain_plugin.hpp.

get_transaction_id_params

using sysio::chain_apis::read_only::get_transaction_id_params = transaction

Definition at line 314 of file chain_plugin.hpp.

get_transaction_id_result

using sysio::chain_apis::read_only::get_transaction_id_result = transaction_id_type

Definition at line 315 of file chain_plugin.hpp.

Constructor & Destructor Documentation

read_only()

sysio::chain_apis::read_only::read_only ( const controller & db, const std::optional< account_query_db > & aqdb, const fc::microseconds & abi_serializer_max_time, const producer_plugin * producer_plug, const trx_finality_status_processing * trx_finality_status_proc )

inline

Definition at line 99 of file chain_plugin.hpp.

      : db(db), aqdb(aqdb), abi_serializer_max_time(abi_serializer_max_time), producer_plug(producer_plug), trx_finality_status_proc(trx_finality_status_proc) {
   }

Member Function Documentation

abi_bin_to_json()

abi_bin_to_json_result sysio::chain_apis::read_only::abi_bin_to_json

(

const abi_bin_to_json_params &

params

)

const

abi_json_to_bin()

read_only::abi_json_to_bin_result sysio::chain_apis::read_only::abi_json_to_bin

(

const abi_json_to_bin_params &

params

)

const

Definition at line 2601 of file chain_plugin.cpp.

                                                                                                                   {
   abi_json_to_bin_result result;
   const auto code_account = db.db().find<account_object,by_name>( params.code );
   SYS_ASSERT(code_account != nullptr, contract_query_exception, "Contract can't be found ${contract}", ("contract", params.code));
 
   abi_def abi;
   if( abi_serializer::to_abi(code_account->abi, abi) ) {
      abi_serializer abis( abi, abi_serializer::create_yield_function( abi_serializer_max_time ) );
      auto action_type = abis.get_action_type(params.action);
      SYS_ASSERT(!action_type.empty(), action_validate_exception, "Unknown action ${action} in contract ${contract}", ("action", params.action)("contract", params.code));
      try {
         result.binargs = abis.variant_to_binary( action_type, params.args, abi_serializer::create_yield_function( abi_serializer_max_time ), shorten_abi_errors );
      } SYS_RETHROW_EXCEPTIONS(chain::invalid_action_args_exception,
                                "'${args}' is invalid args for action '${action}' code '${code}'. expected '${proto}'",
                                ("args", params.args)("action", params.action)("code", params.code)("proto", action_abi_to_variant(abi, action_type)))
   } else {
      SYS_ASSERT(false, abi_not_found_exception, "No ABI found for ${contract}", ("contract", params.code));
   }
   return result;
} FC_RETHROW_EXCEPTIONS( warn, "code: ${code}, action: ${action}, args: ${args}",

Here is the call graph for this function:

compute_transaction()

void sysio::chain_apis::read_only::compute_transaction	(	const compute_transaction_params &	params,
		chain::plugin_interface::next_function< compute_transaction_results >	next ) const

copy_inline_row()

static void sysio::chain_apis::read_only::copy_inline_row ( const chain::key_value_object & obj, vector< char > & data )

inlinestatic

Definition at line 453 of file chain_plugin.hpp.

                                                                                     {
      data.resize( obj.value.size() );
      memcpy( data.data(), obj.value.data(), obj.value.size() );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

extract_core_symbol()

chain::symbol sysio::chain_apis::read_only::extract_core_symbol

(

)

const

get_abi()

read_only::get_abi_results sysio::chain_apis::read_only::get_abi

(

const get_abi_params &

params

)

const

Definition at line 2348 of file chain_plugin.cpp.

                                                                               {
   get_abi_results result;
   result.account_name = params.account_name;
   const auto& d = db.db();
   const auto& accnt  = d.get<account_object,by_name>( params.account_name );
 
   abi_def abi;
   if( abi_serializer::to_abi(accnt.abi, abi) ) {
      result.abi = std::move(abi);
   }
 
   return result;
}

Here is the call graph for this function:

get_account()

read_only::get_account_results sysio::chain_apis::read_only::get_account

(

const get_account_params &

params

)

const

TODO: lookup perm->parent name

Definition at line 2429 of file chain_plugin.cpp.

                                                                                           {
   get_account_results result;
   result.account_name = params.account_name;
 
   const auto& d = db.db();
   const auto& rm = db.get_resource_limits_manager();
 
   result.head_block_num  = db.head_block_num();
   result.head_block_time = db.head_block_time();
 
   rm.get_account_limits( result.account_name, result.ram_quota, result.net_weight, result.cpu_weight );
 
   const auto& accnt_obj = db.get_account( result.account_name );
   const auto& accnt_metadata_obj = db.db().get<account_metadata_object,by_name>( result.account_name );
 
   result.privileged       = accnt_metadata_obj.is_privileged();
   result.last_code_update = accnt_metadata_obj.last_code_update;
   result.created          = accnt_obj.creation_date;
 
   uint32_t greylist_limit = db.is_resource_greylisted(result.account_name) ? 1 : config::maximum_elastic_resource_multiplier;
   result.net_limit = rm.get_account_net_limit_ex( result.account_name, greylist_limit).first;
   result.cpu_limit = rm.get_account_cpu_limit_ex( result.account_name, greylist_limit).first;
   result.ram_usage = rm.get_account_ram_usage( result.account_name );
 
   if ( producer_plug ) {  // producer_plug is null when called from chain_plugin_tests.cpp and get_table_tests.cpp
      account_resource_limit subjective_cpu_bill_limit;
      subjective_cpu_bill_limit.used = producer_plug->get_subjective_bill( result.account_name, fc::time_point::now() );
      result.subjective_cpu_bill_limit = subjective_cpu_bill_limit;
   }
 
   const auto linked_action_map = ([&](){
      const auto& links = d.get_index<permission_link_index,by_permission_name>();
      auto iter = links.lower_bound( boost::make_tuple( params.account_name ) );
 
      std::multimap<name, linked_action> result;
      while (iter != links.end() && iter->account == params.account_name ) {
         auto action = iter->message_type.empty() ? std::optional<name>() : std::optional<name>(iter->message_type);
         result.emplace(std::make_pair(iter->required_permission, linked_action{iter->code, std::move(action)}));
         ++iter;
      }
 
      return result;
   })();
 
   auto get_linked_actions = [&](chain::name perm_name) {
      auto link_bounds = linked_action_map.equal_range(perm_name);
      auto linked_actions = std::vector<linked_action>();
      linked_actions.reserve(linked_action_map.count(perm_name));
      for (auto link = link_bounds.first; link != link_bounds.second; ++link) {
         linked_actions.push_back(link->second);
      }
      return linked_actions;
   };
 
   const auto& permissions = d.get_index<permission_index,by_owner>();
   auto perm = permissions.lower_bound( boost::make_tuple( params.account_name ) );
   while( perm != permissions.end() && perm->owner == params.account_name ) {
      name parent;
 
      // Don't lookup parent if null
      if( perm->parent._id ) {
         const auto* p = d.find<permission_object,by_id>( perm->parent );
         if( p ) {
            SYS_ASSERT(perm->owner == p->owner, invalid_parent_permission, "Invalid parent permission");
            parent = p->name;
         }
      }
 
      auto linked_actions = get_linked_actions(perm->name);
 
      result.permissions.push_back( permission{ perm->name, parent, perm->auth.to_authority(), std::move(linked_actions)} );
      ++perm;
   }
 
   // add sysio.any linked authorizations
   result.sysio_any_linked_actions = get_linked_actions(chain::config::sysio_any_name);
 
   const auto& code_account = db.db().get<account_object,by_name>( config::system_account_name );
 
   abi_def abi;
   if( abi_serializer::to_abi(code_account.abi, abi) ) {
      abi_serializer abis( abi, abi_serializer::create_yield_function( abi_serializer_max_time ) );
 
      const auto token_code = "sysio.token"_n;
 
      auto core_symbol = extract_core_symbol();
 
      if (params.expected_core_symbol)
         core_symbol = *(params.expected_core_symbol);
 
      const auto* t_id = d.find<chain::table_id_object, chain::by_code_scope_table>(boost::make_tuple( token_code, params.account_name, "accounts"_n ));
      if( t_id != nullptr ) {
         const auto &idx = d.get_index<key_value_index, by_scope_primary>();
         auto it = idx.find(boost::make_tuple( t_id->id, core_symbol.to_symbol_code() ));
         if( it != idx.end() && it->value.size() >= sizeof(asset) ) {
            asset bal;
            fc::datastream<const char *> ds(it->value.data(), it->value.size());
            fc::raw::unpack(ds, bal);
 
            if( bal.get_symbol().valid() && bal.get_symbol() == core_symbol ) {
               result.core_liquid_balance = bal;
            }
         }
      }
 
      t_id = d.find<chain::table_id_object, chain::by_code_scope_table>(boost::make_tuple( config::system_account_name, params.account_name, "userres"_n ));
      if (t_id != nullptr) {
         const auto &idx = d.get_index<key_value_index, by_scope_primary>();
         auto it = idx.find(boost::make_tuple( t_id->id, params.account_name.to_uint64_t() ));
         if ( it != idx.end() ) {
            vector<char> data;
            copy_inline_row(*it, data);
            result.total_resources = abis.binary_to_variant( "user_resources", data, abi_serializer::create_yield_function( abi_serializer_max_time ), shorten_abi_errors );
         }
      }
 
      t_id = d.find<chain::table_id_object, chain::by_code_scope_table>(boost::make_tuple( config::system_account_name, params.account_name, "delband"_n ));
      if (t_id != nullptr) {
         const auto &idx = d.get_index<key_value_index, by_scope_primary>();
         auto it = idx.find(boost::make_tuple( t_id->id, params.account_name.to_uint64_t() ));
         if ( it != idx.end() ) {
            vector<char> data;
            copy_inline_row(*it, data);
            result.self_delegated_bandwidth = abis.binary_to_variant( "delegated_bandwidth", data, abi_serializer::create_yield_function( abi_serializer_max_time ), shorten_abi_errors );
         }
      }
 
      t_id = d.find<chain::table_id_object, chain::by_code_scope_table>(boost::make_tuple( config::system_account_name, params.account_name, "refunds"_n ));
      if (t_id != nullptr) {
         const auto &idx = d.get_index<key_value_index, by_scope_primary>();
         auto it = idx.find(boost::make_tuple( t_id->id, params.account_name.to_uint64_t() ));
         if ( it != idx.end() ) {
            vector<char> data;
            copy_inline_row(*it, data);
            result.refund_request = abis.binary_to_variant( "refund_request", data, abi_serializer::create_yield_function( abi_serializer_max_time ), shorten_abi_errors );
         }
      }
 
      t_id = d.find<chain::table_id_object, chain::by_code_scope_table>(boost::make_tuple( config::system_account_name, config::system_account_name, "voters"_n ));
      if (t_id != nullptr) {
         const auto &idx = d.get_index<key_value_index, by_scope_primary>();
         auto it = idx.find(boost::make_tuple( t_id->id, params.account_name.to_uint64_t() ));
         if ( it != idx.end() ) {
            vector<char> data;
            copy_inline_row(*it, data);
            result.voter_info = abis.binary_to_variant( "voter_info", data, abi_serializer::create_yield_function( abi_serializer_max_time ), shorten_abi_errors );
         }
      }
 
      t_id = d.find<chain::table_id_object, chain::by_code_scope_table>(boost::make_tuple( config::system_account_name, config::system_account_name, "rexbal"_n ));
      if (t_id != nullptr) {
         const auto &idx = d.get_index<key_value_index, by_scope_primary>();
         auto it = idx.find(boost::make_tuple( t_id->id, params.account_name.to_uint64_t() ));
         if( it != idx.end() ) {
            vector<char> data;
            copy_inline_row(*it, data);
            result.rex_info = abis.binary_to_variant( "rex_balance", data, abi_serializer::create_yield_function( abi_serializer_max_time ), shorten_abi_errors );
         }
      }
   }
   return result;
}

Here is the call graph for this function:

get_accounts_by_authorizers()

get_accounts_by_authorizers_result sysio::chain_apis::read_only::get_accounts_by_authorizers

(

const get_accounts_by_authorizers_params &

args

)

const

get_activated_protocol_features()

read_only::get_activated_protocol_features_results sysio::chain_apis::read_only::get_activated_protocol_features

(

const get_activated_protocol_features_params &

params

)

const

10ms max time

Definition at line 1472 of file chain_plugin.cpp.

                                                                                                               {
   read_only::get_activated_protocol_features_results result;
   const auto& pfm = db.get_protocol_feature_manager();
 
   uint32_t lower_bound_value = std::numeric_limits<uint32_t>::lowest();
   uint32_t upper_bound_value = std::numeric_limits<uint32_t>::max();
 
   if( params.lower_bound ) {
      lower_bound_value = *params.lower_bound;
   }
 
   if( params.upper_bound ) {
      upper_bound_value = *params.upper_bound;
   }
 
   if( upper_bound_value < lower_bound_value )
      return result;
 
   auto walk_range = [&]( auto itr, auto end_itr, auto&& convert_iterator ) {
      fc::mutable_variant_object mvo;
      mvo( "activation_ordinal", 0 );
      mvo( "activation_block_num", 0 );
 
      auto& activation_ordinal_value   = mvo["activation_ordinal"];
      auto& activation_block_num_value = mvo["activation_block_num"];
 
      auto cur_time = fc::time_point::now();
      auto end_time = cur_time + fc::microseconds(1000 * 10); 
      for( unsigned int count = 0;
           cur_time <= end_time && count < params.limit && itr != end_itr;
           ++itr, cur_time = fc::time_point::now() )
      {
         const auto& conv_itr = convert_iterator( itr );
         activation_ordinal_value   = conv_itr.activation_ordinal();
         activation_block_num_value = conv_itr.activation_block_num();
 
         result.activated_protocol_features.emplace_back( conv_itr->to_variant( false, &mvo ) );
         ++count;
      }
      if( itr != end_itr ) {
         result.more = convert_iterator( itr ).activation_ordinal() ;
      }
   };
 
   auto get_next_if_not_end = [&pfm]( auto&& itr ) {
      if( itr == pfm.cend() ) return itr;
 
      ++itr;
      return itr;
   };
 
   auto lower = ( params.search_by_block_num ? pfm.lower_bound( lower_bound_value )
                                             : pfm.at_activation_ordinal( lower_bound_value ) );
 
   auto upper = ( params.search_by_block_num ? pfm.upper_bound( upper_bound_value )
                                             : get_next_if_not_end( pfm.at_activation_ordinal( upper_bound_value ) ) );
 
   if( params.reverse ) {
      walk_range( std::make_reverse_iterator(upper), std::make_reverse_iterator(lower),
                  []( auto&& ritr ) { return --(ritr.base()); } );
   } else {
      walk_range( lower, upper, []( auto&& itr ) { return itr; } );
   }
 
   return result;
}

Here is the call graph for this function:

get_block()

fc::variant sysio::chain_apis::read_only::get_block

(

const get_block_params &

params

)

const

Definition at line 2041 of file chain_plugin.cpp.

                                                                            {
   signed_block_ptr block;
   std::optional<uint64_t> block_num;
 
   SYS_ASSERT( !params.block_num_or_id.empty() && params.block_num_or_id.size() <= 64,
               chain::block_id_type_exception,
               "Invalid Block number or ID, must be greater than 0 and less than 64 characters"
   );
 
   try {
      block_num = fc::to_uint64(params.block_num_or_id);
   } catch( ... ) {}
 
   if( block_num ) {
      block = db.fetch_block_by_number( *block_num );
   } else {
      try {
         block = db.fetch_block_by_id( fc::variant(params.block_num_or_id).as<block_id_type>() );
      } SYS_RETHROW_EXCEPTIONS(chain::block_id_type_exception, "Invalid block ID: ${block_num_or_id}", ("block_num_or_id", params.block_num_or_id))
   }
 
   SYS_ASSERT( block, unknown_block_exception, "Could not find block: ${block}", ("block", params.block_num_or_id));
 
   fc::variant pretty_output;
   abi_serializer::to_variant(*block, pretty_output, make_resolver(db, abi_serializer::create_yield_function( abi_serializer_max_time )),
                              abi_serializer::create_yield_function( abi_serializer_max_time ));
 
   const auto block_id = block->calculate_id();
   uint32_t ref_block_prefix = block_id._hash[1];
 
   return fc::mutable_variant_object(pretty_output.get_object())
           ("id", block_id)
           ("block_num",block->block_num())
           ("ref_block_prefix", ref_block_prefix);
}

Here is the call graph for this function:

get_block_header_state()

fc::variant sysio::chain_apis::read_only::get_block_header_state

(

const get_block_header_state_params &

params

)

const

Definition at line 2106 of file chain_plugin.cpp.

                                                                                             {
   block_state_ptr b;
   std::optional<uint64_t> block_num;
   std::exception_ptr e;
   try {
      block_num = fc::to_uint64(params.block_num_or_id);
   } catch( ... ) {}
 
   if( block_num ) {
      b = db.fetch_block_state_by_number(*block_num);
   } else {
      try {
         b = db.fetch_block_state_by_id(fc::variant(params.block_num_or_id).as<block_id_type>());
      } SYS_RETHROW_EXCEPTIONS(chain::block_id_type_exception, "Invalid block ID: ${block_num_or_id}", ("block_num_or_id", params.block_num_or_id))
   }
 
   SYS_ASSERT( b, unknown_block_exception, "Could not find reversible block: ${block}", ("block", params.block_num_or_id));
 
   fc::variant vo;
   fc::to_variant( static_cast<const block_header_state&>(*b), vo );
   return vo;
}

Here is the call graph for this function:

get_block_info()

fc::variant sysio::chain_apis::read_only::get_block_info

(

const get_block_info_params &

params

)

const

Definition at line 2077 of file chain_plugin.cpp.

                                                                                      {
 
   signed_block_ptr block;
   try {
         block = db.fetch_block_by_number( params.block_num );
   } catch (...)   {
      // assert below will handle the invalid block num
   }
 
   SYS_ASSERT( block, unknown_block_exception, "Could not find block: ${block}", ("block", params.block_num));
 
   const auto id = block->calculate_id();
   const uint32_t ref_block_prefix = id._hash[1];
 
   return fc::mutable_variant_object ()
         ("block_num", block->block_num())
         ("ref_block_num", static_cast<uint16_t>(block->block_num()))
         ("id", id)
         ("timestamp", block->timestamp)
         ("producer", block->producer)
         ("confirmed", block->confirmed)
         ("previous", block->previous)
         ("transaction_mroot", block->transaction_mroot)
         ("action_mroot", block->action_mroot)
         ("schedule_version", block->schedule_version)
         ("producer_signature", block->producer_signature)
         ("ref_block_prefix", ref_block_prefix);
}

Here is the call graph for this function:

get_code()

read_only::get_code_results sysio::chain_apis::read_only::get_code

(

const get_code_params &

params

)

const

Definition at line 2362 of file chain_plugin.cpp.

                                                                                  {
   get_code_results result;
   result.account_name = params.account_name;
   const auto& d = db.db();
   const auto& accnt_obj          = d.get<account_object,by_name>( params.account_name );
   const auto& accnt_metadata_obj = d.get<account_metadata_object,by_name>( params.account_name );
 
   SYS_ASSERT( params.code_as_wasm, unsupported_feature, "Returning WAST from get_code is no longer supported" );
 
   if( accnt_metadata_obj.code_hash != digest_type() ) {
      const auto& code_obj = d.get<code_object, by_code_hash>(accnt_metadata_obj.code_hash);
      result.wasm = string(code_obj.code.begin(), code_obj.code.end());
      result.code_hash = code_obj.code_hash;
   }
 
   abi_def abi;
   if( abi_serializer::to_abi(accnt_obj.abi, abi) ) {
      result.abi = std::move(abi);
   }
 
   return result;
}

Here is the call graph for this function:

get_code_hash()

read_only::get_code_hash_results sysio::chain_apis::read_only::get_code_hash

(

const get_code_hash_params &

params

)

const

Definition at line 2385 of file chain_plugin.cpp.

                                                                                                 {
   get_code_hash_results result;
   result.account_name = params.account_name;
   const auto& d = db.db();
   const auto& accnt  = d.get<account_metadata_object,by_name>( params.account_name );
 
   if( accnt.code_hash != digest_type() )
      result.code_hash = accnt.code_hash;
 
   return result;
}

get_currency_balance()

vector< asset > sysio::chain_apis::read_only::get_currency_balance

(

const get_currency_balance_params &

params

)

const

Definition at line 1797 of file chain_plugin.cpp.

                                                                                                  {
 
   const abi_def abi = sysio::chain_apis::get_abi( db, p.code );
   (void)get_table_type( abi, name("accounts") );
 
   vector<asset> results;
   walk_key_value_table(p.code, p.account, "accounts"_n, [&](const key_value_object& obj){
      SYS_ASSERT( obj.value.size() >= sizeof(asset), chain::asset_type_exception, "Invalid data on table");
 
      asset cursor;
      fc::datastream<const char *> ds(obj.value.data(), obj.value.size());
      fc::raw::unpack(ds, cursor);
 
      SYS_ASSERT( cursor.get_symbol().valid(), chain::asset_type_exception, "Invalid asset");
 
      if( !p.symbol || boost::iequals(cursor.symbol_name(), *p.symbol) ) {
        results.emplace_back(cursor);
      }
 
      // return false if we are looking for one and found it, true otherwise
      return !(p.symbol && boost::iequals(cursor.symbol_name(), *p.symbol));
   });
 
   return results;
}

Here is the call graph for this function:

get_currency_stats()

fc::variant sysio::chain_apis::read_only::get_currency_stats

(

const get_currency_stats_params &

params

)

const

Definition at line 1823 of file chain_plugin.cpp.

                                                                                          {
   fc::mutable_variant_object results;
 
   const abi_def abi = sysio::chain_apis::get_abi( db, p.code );
   (void)get_table_type( abi, name("stat") );
 
   uint64_t scope = ( sysio::chain::string_to_symbol( 0, boost::algorithm::to_upper_copy(p.symbol).c_str() ) >> 8 );
 
   walk_key_value_table(p.code, name(scope), "stat"_n, [&](const key_value_object& obj){
      SYS_ASSERT( obj.value.size() >= sizeof(read_only::get_currency_stats_result), chain::asset_type_exception, "Invalid data on table");
 
      fc::datastream<const char *> ds(obj.value.data(), obj.value.size());
      read_only::get_currency_stats_result result;
 
      fc::raw::unpack(ds, result.supply);
      fc::raw::unpack(ds, result.max_supply);
      fc::raw::unpack(ds, result.issuer);
 
      results[result.supply.symbol_name()] = result;
      return true;
   });
 
   return results;
}

Here is the call graph for this function:

get_info()

read_only::get_info_results sysio::chain_apis::read_only::get_info

(

const get_info_params &

)

const

Definition at line 1416 of file chain_plugin.cpp.

                                                                                   {
   const auto& rm = db.get_resource_limits_manager();
 
   return {
      itoh(static_cast<uint32_t>(app().version())),
      db.get_chain_id(),
      db.head_block_num(),
      db.last_irreversible_block_num(),
      db.last_irreversible_block_id(),
      db.head_block_id(),
      db.head_block_time(),
      db.head_block_producer(),
      rm.get_virtual_block_cpu_limit(),
      rm.get_virtual_block_net_limit(),
      rm.get_block_cpu_limit(),
      rm.get_block_net_limit(),
      //std::bitset<64>(db.get_dynamic_global_properties().recent_slots_filled).to_string(),
      //__builtin_popcountll(db.get_dynamic_global_properties().recent_slots_filled) / 64.0,
      app().version_string(),
      db.fork_db_pending_head_block_num(),
      db.fork_db_pending_head_block_id(),
      app().full_version_string(),
      rm.get_total_cpu_weight(),
      rm.get_total_net_weight(),
      db.earliest_available_block_num(),
      db.last_irreversible_block_time()
   };
}

Here is the call graph for this function:

get_producer_schedule()

read_only::get_producer_schedule_result sysio::chain_apis::read_only::get_producer_schedule

(

const get_producer_schedule_params &

params

)

const

Definition at line 1937 of file chain_plugin.cpp.

                                                                                                                             {
   read_only::get_producer_schedule_result result;
   to_variant(db.active_producers(), result.active);
   if(!db.pending_producers().producers.empty())
      to_variant(db.pending_producers(), result.pending);
   auto proposed = db.proposed_producers();
   if(proposed && !proposed->producers.empty())
      to_variant(*proposed, result.proposed);
   return result;
}

Here is the call graph for this function:

get_producers()

read_only::get_producers_result sysio::chain_apis::read_only::get_producers

(

const get_producers_params &

params

)

const

Definition at line 1864 of file chain_plugin.cpp.

                                                                                                         {
   const abi_def abi = sysio::chain_apis::get_abi(db, config::system_account_name);
   const auto table_type = get_table_type(abi, "producers"_n);
   const abi_serializer abis{ abi, abi_serializer::create_yield_function( abi_serializer_max_time ) };
   SYS_ASSERT(table_type == KEYi64, chain::contract_table_query_exception, "Invalid table type ${type} for table producers", ("type",table_type));
 
   const auto& d = db.db();
   const auto lower = name{p.lower_bound};
 
   static const uint8_t secondary_index_num = 0;
   const auto* const table_id = d.find<chain::table_id_object, chain::by_code_scope_table>(
           boost::make_tuple(config::system_account_name, config::system_account_name, "producers"_n));
   const auto* const secondary_table_id = d.find<chain::table_id_object, chain::by_code_scope_table>(
           boost::make_tuple(config::system_account_name, config::system_account_name, name("producers"_n.to_uint64_t() | secondary_index_num)));
   SYS_ASSERT(table_id && secondary_table_id, chain::contract_table_query_exception, "Missing producers table");
 
   const auto& kv_index = d.get_index<key_value_index, by_scope_primary>();
   const auto& secondary_index = d.get_index<index_double_index>().indices();
   const auto& secondary_index_by_primary = secondary_index.get<by_primary>();
   const auto& secondary_index_by_secondary = secondary_index.get<by_secondary>();
 
   read_only::get_producers_result result;
   const auto stopTime = fc::time_point::now() + fc::microseconds(1000 * 10); // 10ms
   vector<char> data;
 
   auto it = [&]{
      if(lower.to_uint64_t() == 0)
         return secondary_index_by_secondary.lower_bound(
            boost::make_tuple(secondary_table_id->id, to_softfloat64(std::numeric_limits<double>::lowest()), 0));
      else
         return secondary_index.project<by_secondary>(
            secondary_index_by_primary.lower_bound(
               boost::make_tuple(secondary_table_id->id, lower.to_uint64_t())));
   }();
 
   for( ; it != secondary_index_by_secondary.end() && it->t_id == secondary_table_id->id; ++it ) {
      if (result.rows.size() >= p.limit || fc::time_point::now() > stopTime) {
         result.more = name{it->primary_key}.to_string();
         break;
      }
      copy_inline_row(*kv_index.find(boost::make_tuple(table_id->id, it->primary_key)), data);
      if (p.json)
         result.rows.emplace_back( abis.binary_to_variant( abis.get_table_type("producers"_n), data, abi_serializer::create_yield_function( abi_serializer_max_time ), shorten_abi_errors ) );
      else
         result.rows.emplace_back(fc::variant(data));
   }
 
   result.total_producer_vote_weight = get_global_row(d, abi, abis, abi_serializer_max_time, shorten_abi_errors)["total_producer_vote_weight"].as_double();
   return result;
} catch (...) {
   read_only::get_producers_result result;
 
   for (auto p : db.active_producers().producers) {
      auto row = fc::mutable_variant_object()
         ("owner", p.producer_name)
         ("producer_authority", p.authority)
         ("url", "")
         ("total_votes", 0.0f);
 
      // detect a legacy key and maintain API compatibility for those entries
      if (std::holds_alternative<block_signing_authority_v0>(p.authority)) {
         const auto& auth = std::get<block_signing_authority_v0>(p.authority);
         if (auth.keys.size() == 1 && auth.keys.back().weight == auth.threshold) {
            row("producer_key", auth.keys.back().key);
         }
      }
 
      result.rows.push_back(row);
   }
 
   return result;
}

Here is the call graph for this function:

get_raw_abi()

read_only::get_raw_abi_results sysio::chain_apis::read_only::get_raw_abi

(

const get_raw_abi_params &

params

)

const

Definition at line 2413 of file chain_plugin.cpp.

                                                                                           {
   get_raw_abi_results result;
   result.account_name = params.account_name;
 
   const auto& d = db.db();
   const auto& accnt_obj          = d.get<account_object,by_name>(params.account_name);
   const auto& accnt_metadata_obj = d.get<account_metadata_object,by_name>(params.account_name);
   result.abi_hash = fc::sha256::hash( accnt_obj.abi.data(), accnt_obj.abi.size() );
   if( accnt_metadata_obj.code_hash != digest_type() )
      result.code_hash = accnt_metadata_obj.code_hash;
   if( !params.abi_hash || *params.abi_hash != result.abi_hash )
      result.abi = blob{{accnt_obj.abi.begin(), accnt_obj.abi.end()}};
 
   return result;
}

Here is the call graph for this function:

get_raw_code_and_abi()

read_only::get_raw_code_and_abi_results sysio::chain_apis::read_only::get_raw_code_and_abi

(

const get_raw_code_and_abi_params &

params

)

const

Definition at line 2397 of file chain_plugin.cpp.

                                                                                                                     {
   get_raw_code_and_abi_results result;
   result.account_name = params.account_name;
 
   const auto& d = db.db();
   const auto& accnt_obj          = d.get<account_object,by_name>(params.account_name);
   const auto& accnt_metadata_obj = d.get<account_metadata_object,by_name>(params.account_name);
   if( accnt_metadata_obj.code_hash != digest_type() ) {
      const auto& code_obj = d.get<code_object, by_code_hash>(accnt_metadata_obj.code_hash);
      result.wasm = blob{{code_obj.code.begin(), code_obj.code.end()}};
   }
   result.abi = blob{{accnt_obj.abi.begin(), accnt_obj.abi.end()}};
 
   return result;
}

get_required_keys()

get_required_keys_result sysio::chain_apis::read_only::get_required_keys

(

const get_required_keys_params &

params

)

const

get_scheduled_transactions()

read_only::get_scheduled_transactions_result sysio::chain_apis::read_only::get_scheduled_transactions

(

const get_scheduled_transactions_params &

params

)

const

10ms max time

Definition at line 1969 of file chain_plugin.cpp.

                                                                                                 {
   const auto& d = db.db();
 
   const auto& idx_by_delay = d.get_index<generated_transaction_multi_index,by_delay>();
   auto itr = ([&](){
      if (!p.lower_bound.empty()) {
         try {
            auto when = time_point::from_iso_string( p.lower_bound );
            return idx_by_delay.lower_bound(boost::make_tuple(when));
         } catch (...) {
            try {
               auto txid = transaction_id_type(p.lower_bound);
               const auto& by_txid = d.get_index<generated_transaction_multi_index,by_trx_id>();
               auto itr = by_txid.find( txid );
               if (itr == by_txid.end()) {
                  SYS_THROW(transaction_exception, "Unknown Transaction ID: ${txid}", ("txid", txid));
               }
 
               return d.get_index<generated_transaction_multi_index>().indices().project<by_delay>(itr);
 
            } catch (...) {
               return idx_by_delay.end();
            }
         }
      } else {
         return idx_by_delay.begin();
      }
   })();
 
   read_only::get_scheduled_transactions_result result;
 
   auto resolver = make_resolver(db, abi_serializer::create_yield_function( abi_serializer_max_time ));
 
   uint32_t remaining = p.limit;
   auto time_limit = fc::time_point::now() + fc::microseconds(1000 * 10); 
   while (itr != idx_by_delay.end() && remaining > 0 && time_limit > fc::time_point::now()) {
      auto row = fc::mutable_variant_object()
              ("trx_id", itr->trx_id)
              ("sender", itr->sender)
              ("sender_id", itr->sender_id)
              ("payer", itr->payer)
              ("delay_until", itr->delay_until)
              ("expiration", itr->expiration)
              ("published", itr->published)
      ;
 
      if (p.json) {
         fc::variant pretty_transaction;
 
         transaction trx;
         fc::datastream<const char*> ds( itr->packed_trx.data(), itr->packed_trx.size() );
         fc::raw::unpack(ds,trx);
 
         abi_serializer::to_variant(trx, pretty_transaction, resolver, abi_serializer::create_yield_function( abi_serializer_max_time ));
         row("transaction", pretty_transaction);
      } else {
         auto packed_transaction = bytes(itr->packed_trx.begin(), itr->packed_trx.end());
         row("transaction", packed_transaction);
      }
 
      result.transactions.emplace_back(std::move(row));
      ++itr;
      remaining--;
   }
 
   if (itr != idx_by_delay.end()) {
      result.more = string(itr->trx_id);
   }
 
   return result;
}

Here is the call graph for this function:

get_table_by_scope()

read_only::get_table_by_scope_result sysio::chain_apis::read_only::get_table_by_scope

(

const get_table_by_scope_params &

params

)

const

10ms max time

Definition at line 1749 of file chain_plugin.cpp.

                                                                                                                   {
   read_only::get_table_by_scope_result result;
   const auto& d = db.db();
 
   const auto& idx = d.get_index<chain::table_id_multi_index, chain::by_code_scope_table>();
   auto lower_bound_lookup_tuple = std::make_tuple( p.code, name(std::numeric_limits<uint64_t>::lowest()), p.table );
   auto upper_bound_lookup_tuple = std::make_tuple( p.code, name(std::numeric_limits<uint64_t>::max()),
                                                    (p.table.empty() ? name(std::numeric_limits<uint64_t>::max()) : p.table) );
 
   if( p.lower_bound.size() ) {
      uint64_t scope = convert_to_type<uint64_t>(p.lower_bound, "lower_bound scope");
      std::get<1>(lower_bound_lookup_tuple) = name(scope);
   }
 
   if( p.upper_bound.size() ) {
      uint64_t scope = convert_to_type<uint64_t>(p.upper_bound, "upper_bound scope");
      std::get<1>(upper_bound_lookup_tuple) = name(scope);
   }
 
   if( upper_bound_lookup_tuple < lower_bound_lookup_tuple )
      return result;
 
   auto walk_table_range = [&]( auto itr, auto end_itr ) {
      auto cur_time = fc::time_point::now();
      auto end_time = cur_time + fc::microseconds(1000 * 10); 
      for( unsigned int count = 0; cur_time <= end_time && count < p.limit && itr != end_itr; ++itr, cur_time = fc::time_point::now() ) {
         if( p.table && itr->table != p.table ) continue;
 
         result.rows.push_back( {itr->code, itr->scope, itr->table, itr->payer, itr->count} );
 
         ++count;
      }
      if( itr != end_itr ) {
         result.more = itr->scope.to_string();
      }
   };
 
   auto lower = idx.lower_bound( lower_bound_lookup_tuple );
   auto upper = idx.upper_bound( upper_bound_lookup_tuple );
   if( p.reverse && *p.reverse ) {
      walk_table_range( boost::make_reverse_iterator(upper), boost::make_reverse_iterator(lower) );
   } else {
      walk_table_range( lower, upper );
   }
 
   return result;
}

Here is the call graph for this function:

get_table_index_name()

uint64_t sysio::chain_apis::read_only::get_table_index_name ( const read_only::get_table_rows_params & p, bool & primary )

static

Definition at line 1539 of file chain_plugin.cpp.

                                                                                               {
   using boost::algorithm::starts_with;
   // see multi_index packing of index name
   const uint64_t table = p.table.to_uint64_t();
   uint64_t index = table & 0xFFFFFFFFFFFFFFF0ULL;
   SYS_ASSERT( index == table, chain::contract_table_query_exception, "Unsupported table name: ${n}", ("n", p.table) );
 
   primary = false;
   uint64_t pos = 0;
   if (p.index_position.empty() || p.index_position == "first" || p.index_position == "primary" || p.index_position == "one") {
      primary = true;
   } else if (starts_with(p.index_position, "sec") || p.index_position == "two") { // second, secondary
   } else if (starts_with(p.index_position , "ter") || starts_with(p.index_position, "th")) { // tertiary, ternary, third, three
      pos = 1;
   } else if (starts_with(p.index_position, "fou")) { // four, fourth
      pos = 2;
   } else if (starts_with(p.index_position, "fi")) { // five, fifth
      pos = 3;
   } else if (starts_with(p.index_position, "six")) { // six, sixth
      pos = 4;
   } else if (starts_with(p.index_position, "sev")) { // seven, seventh
      pos = 5;
   } else if (starts_with(p.index_position, "eig")) { // eight, eighth
      pos = 6;
   } else if (starts_with(p.index_position, "nin")) { // nine, ninth
      pos = 7;
   } else if (starts_with(p.index_position, "ten")) { // ten, tenth
      pos = 8;
   } else {
      try {
         pos = fc::to_uint64( p.index_position );
      } catch(...) {
         SYS_ASSERT( false, chain::contract_table_query_exception, "Invalid index_position: ${p}", ("p", p.index_position));
      }
      if (pos < 2) {
         primary = true;
         pos = 0;
      } else {
         pos -= 2;
      }
   }
   index |= (pos & 0x000000000000000FULL);
   return index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_table_rows()

read_only::get_table_rows_result sysio::chain_apis::read_only::get_table_rows

(

const get_table_rows_params &

params

)

const

Definition at line 1682 of file chain_plugin.cpp.

                                                                                                       {
   const abi_def abi = sysio::chain_apis::get_abi( db, p.code );
   bool primary = false;
   auto table_with_index = get_table_index_name( p, primary );
   if( primary ) {
      SYS_ASSERT( p.table == table_with_index, chain::contract_table_query_exception, "Invalid table name ${t}", ( "t", p.table ));
      auto table_type = get_table_type( abi, p.table );
      if( table_type == KEYi64 || p.key_type == "i64" || p.key_type == "name" ) {
         return get_table_rows_ex<key_value_index>(p,abi);
      }
      SYS_ASSERT( false, chain::contract_table_query_exception,  "Invalid table type ${type}", ("type",table_type)("abi",abi));
   } else {
      SYS_ASSERT( !p.key_type.empty(), chain::contract_table_query_exception, "key type required for non-primary index" );
 
      if (p.key_type == chain_apis::i64 || p.key_type == "name") {
         return get_table_rows_by_seckey<index64_index, uint64_t>(p, abi, [](uint64_t v)->uint64_t {
            return v;
         });
      }
      else if (p.key_type == chain_apis::i128) {
         return get_table_rows_by_seckey<index128_index, uint128_t>(p, abi, [](uint128_t v)->uint128_t {
            return v;
         });
      }
      else if (p.key_type == chain_apis::i256) {
         if ( p.encode_type == chain_apis::hex) {
            using  conv = keytype_converter<chain_apis::sha256,chain_apis::hex>;
            return get_table_rows_by_seckey<conv::index_type, conv::input_type>(p, abi, conv::function());
         }
         using  conv = keytype_converter<chain_apis::i256>;
         return get_table_rows_by_seckey<conv::index_type, conv::input_type>(p, abi, conv::function());
      }
      else if (p.key_type == chain_apis::float64) {
         return get_table_rows_by_seckey<index_double_index, double>(p, abi, [](double v)->float64_t {
            float64_t f;
            double_to_float64(v, f);
            return f;
         });
      }
      else if (p.key_type == chain_apis::float128) {
         if ( p.encode_type == chain_apis::hex) {
            return get_table_rows_by_seckey<index_long_double_index, uint128_t>(p, abi, [](uint128_t v)->float128_t{
               float128_t f;
               uint128_to_float128(v, f);
               return f;
            });
         }
         return get_table_rows_by_seckey<index_long_double_index, double>(p, abi, [](double v)->float128_t{
            float64_t f;
            double_to_float64(v, f);
            float128_t f128;
            f64_to_f128M(f, &f128);
            return f128;
         });
      }
      else if (p.key_type == chain_apis::sha256) {
         using  conv = keytype_converter<chain_apis::sha256,chain_apis::hex>;
         return get_table_rows_by_seckey<conv::index_type, conv::input_type>(p, abi, conv::function());
      }
      else if(p.key_type == chain_apis::ripemd160) {
         using  conv = keytype_converter<chain_apis::ripemd160,chain_apis::hex>;
         return get_table_rows_by_seckey<conv::index_type, conv::input_type>(p, abi, conv::function());
      }
      SYS_ASSERT(false, chain::contract_table_query_exception,  "Unsupported secondary index type: ${t}", ("t", p.key_type));
   }
}

Here is the call graph for this function:

get_table_rows_by_seckey()

template<typename IndexType , typename SecKeyType , typename ConvFn >

read_only::get_table_rows_result sysio::chain_apis::read_only::get_table_rows_by_seckey ( const read_only::get_table_rows_params & p, const abi_def & abi, ConvFn conv ) const

inline

10ms max time

Definition at line 480 of file chain_plugin.hpp.

                                                                                                                                            {
      read_only::get_table_rows_result result;
      const auto& d = db.db();
 
      name scope{ convert_to_type<uint64_t>(p.scope, "scope") };
 
      abi_serializer abis;
      abis.set_abi(abi, abi_serializer::create_yield_function( abi_serializer_max_time ) );
      bool primary = false;
      const uint64_t table_with_index = get_table_index_name(p, primary);
      const auto* t_id = d.find<chain::table_id_object, chain::by_code_scope_table>(boost::make_tuple(p.code, scope, p.table));
      const auto* index_t_id = d.find<chain::table_id_object, chain::by_code_scope_table>(boost::make_tuple(p.code, scope, name(table_with_index)));
      if( t_id != nullptr && index_t_id != nullptr ) {
         using secondary_key_type = std::result_of_t<decltype(conv)(SecKeyType)>;
         static_assert( std::is_same<typename IndexType::value_type::secondary_key_type, secondary_key_type>::value, "Return type of conv does not match type of secondary key for IndexType" );
 
         const auto& secidx = d.get_index<IndexType, chain::by_secondary>();
         auto lower_bound_lookup_tuple = std::make_tuple( index_t_id->id._id,
                                                          sysio::chain::secondary_key_traits<secondary_key_type>::true_lowest(),
                                                          std::numeric_limits<uint64_t>::lowest() );
         auto upper_bound_lookup_tuple = std::make_tuple( index_t_id->id._id,
                                                          sysio::chain::secondary_key_traits<secondary_key_type>::true_highest(),
                                                          std::numeric_limits<uint64_t>::max() );
 
         if( p.lower_bound.size() ) {
            if( p.key_type == "name" ) {
               name s(p.lower_bound);
               SecKeyType lv = convert_to_type<SecKeyType>( s.to_string(), "lower_bound name" ); // avoids compiler error
               std::get<1>(lower_bound_lookup_tuple) = conv( lv );
            } else {
               SecKeyType lv = convert_to_type<SecKeyType>( p.lower_bound, "lower_bound" );
               std::get<1>(lower_bound_lookup_tuple) = conv( lv );
            }
         }
 
         if( p.upper_bound.size() ) {
            if( p.key_type == "name" ) {
               name s(p.upper_bound);
               SecKeyType uv = convert_to_type<SecKeyType>( s.to_string(), "upper_bound name" );
               std::get<1>(upper_bound_lookup_tuple) = conv( uv );
            } else {
               SecKeyType uv = convert_to_type<SecKeyType>( p.upper_bound, "upper_bound" );
               std::get<1>(upper_bound_lookup_tuple) = conv( uv );
            }
         }
 
         if( upper_bound_lookup_tuple < lower_bound_lookup_tuple )
            return result;
 
         auto walk_table_row_range = [&]( auto itr, auto end_itr ) {
            auto cur_time = fc::time_point::now();
            auto end_time = cur_time + fc::microseconds(1000 * 10); 
            vector<char> data;
            for( unsigned int count = 0; cur_time <= end_time && count < p.limit && itr != end_itr; ++itr, cur_time = fc::time_point::now() ) {
               const auto* itr2 = d.find<chain::key_value_object, chain::by_scope_primary>( boost::make_tuple(t_id->id, itr->primary_key) );
               if( itr2 == nullptr ) continue;
               copy_inline_row(*itr2, data);
 
               fc::variant data_var;
               if( p.json ) {
                  data_var = abis.binary_to_variant( abis.get_table_type(p.table), data, abi_serializer::create_yield_function( abi_serializer_max_time ), shorten_abi_errors );
               } else {
                  data_var = fc::variant( data );
               }
 
               if( p.show_payer && *p.show_payer ) {
                  result.rows.emplace_back( fc::mutable_variant_object("data", std::move(data_var))("payer", itr->payer) );
               } else {
                  result.rows.emplace_back( std::move(data_var) );
               }
 
               ++count;
            }
            if( itr != end_itr ) {
               result.more = true;
               result.next_key = convert_to_string(itr->secondary_key, p.key_type, p.encode_type, "next_key - next lower bound");
            }
         };
 
         auto lower = secidx.lower_bound( lower_bound_lookup_tuple );
         auto upper = secidx.upper_bound( upper_bound_lookup_tuple );
         if( p.reverse && *p.reverse ) {
            walk_table_row_range( boost::make_reverse_iterator(upper), boost::make_reverse_iterator(lower) );
         } else {
            walk_table_row_range( lower, upper );
         }
      }
      return result;
   }

Here is the call graph for this function:

get_table_rows_ex()

template<typename IndexType >

read_only::get_table_rows_result sysio::chain_apis::read_only::get_table_rows_ex ( const read_only::get_table_rows_params & p, const abi_def & abi ) const

inline

10ms max time

Definition at line 571 of file chain_plugin.hpp.

                                                                                                                        {
      read_only::get_table_rows_result result;
      const auto& d = db.db();
 
      uint64_t scope = convert_to_type<uint64_t>(p.scope, "scope");
 
      abi_serializer abis;
      abis.set_abi(abi, abi_serializer::create_yield_function( abi_serializer_max_time ));
      const auto* t_id = d.find<chain::table_id_object, chain::by_code_scope_table>(boost::make_tuple(p.code, name(scope), p.table));
      if( t_id != nullptr ) {
         const auto& idx = d.get_index<IndexType, chain::by_scope_primary>();
         auto lower_bound_lookup_tuple = std::make_tuple( t_id->id, std::numeric_limits<uint64_t>::lowest() );
         auto upper_bound_lookup_tuple = std::make_tuple( t_id->id, std::numeric_limits<uint64_t>::max() );
 
         if( p.lower_bound.size() ) {
            if( p.key_type == "name" ) {
               name s(p.lower_bound);
               std::get<1>(lower_bound_lookup_tuple) = s.to_uint64_t();
            } else {
               auto lv = convert_to_type<typename IndexType::value_type::key_type>( p.lower_bound, "lower_bound" );
               std::get<1>(lower_bound_lookup_tuple) = lv;
            }
         }
 
         if( p.upper_bound.size() ) {
            if( p.key_type == "name" ) {
               name s(p.upper_bound);
               std::get<1>(upper_bound_lookup_tuple) = s.to_uint64_t();
            } else {
               auto uv = convert_to_type<typename IndexType::value_type::key_type>( p.upper_bound, "upper_bound" );
               std::get<1>(upper_bound_lookup_tuple) = uv;
            }
         }
 
         if( upper_bound_lookup_tuple < lower_bound_lookup_tuple  )
            return result;
 
         auto walk_table_row_range = [&]( auto itr, auto end_itr ) {
            auto cur_time = fc::time_point::now();
            auto end_time = cur_time + fc::microseconds(1000 * 10); 
            vector<char> data;
            for( unsigned int count = 0; cur_time <= end_time && count < p.limit && itr != end_itr; ++count, ++itr, cur_time = fc::time_point::now() ) {
               copy_inline_row(*itr, data);
 
               fc::variant data_var;
               if( p.json ) {
                  data_var = abis.binary_to_variant( abis.get_table_type(p.table), data, abi_serializer::create_yield_function( abi_serializer_max_time ), shorten_abi_errors );
               } else {
                  data_var = fc::variant( data );
               }
 
               if( p.show_payer && *p.show_payer ) {
                  result.rows.emplace_back( fc::mutable_variant_object("data", std::move(data_var))("payer", itr->payer) );
               } else {
                  result.rows.emplace_back( std::move(data_var) );
               }
            }
            if( itr != end_itr ) {
               result.more = true;
               result.next_key = convert_to_string(itr->primary_key, p.key_type, p.encode_type, "next_key - next lower bound");
            }
         };
 
         auto lower = idx.lower_bound( lower_bound_lookup_tuple );
         auto upper = idx.upper_bound( upper_bound_lookup_tuple );
         if( p.reverse && *p.reverse ) {
            walk_table_row_range( boost::make_reverse_iterator(upper), boost::make_reverse_iterator(lower) );
         } else {
            walk_table_row_range( lower, upper );
         }
      }
      return result;
   }

Here is the call graph for this function:

get_transaction_id()

get_transaction_id_result sysio::chain_apis::read_only::get_transaction_id

(

const get_transaction_id_params &

params

)

const

get_transaction_status()

read_only::get_transaction_status_results sysio::chain_apis::read_only::get_transaction_status

(

const get_transaction_status_params &

params

)

const

Definition at line 1445 of file chain_plugin.cpp.

                                                                                                                                   {
   SYS_ASSERT(trx_finality_status_proc, unsupported_feature, "Transaction Status Interface not enabled.  To enable, configure nodeop with '--transaction-finality-status-max-storage-size-gb <size>'.");
 
   trx_finality_status_processing::chain_state ch_state = trx_finality_status_proc->get_chain_state();
 
   const auto trx_st = trx_finality_status_proc->get_trx_state(param.id);
   // check if block_id is set to a valid value, since trx_finality_status_proc does not use optionals for the block data
   const auto trx_block_valid = trx_st && trx_st->block_id != chain::block_id_type{};
 
   return {
      trx_st ? trx_st->status : "UNKNOWN",
      trx_block_valid ? std::optional<uint32_t>(chain::block_header::num_from_id(trx_st->block_id)) : std::optional<uint32_t>{},
      trx_block_valid ? std::optional<chain::block_id_type>(trx_st->block_id) : std::optional<chain::block_id_type>{},
      trx_block_valid ? std::optional<fc::time_point>(trx_st->block_timestamp) : std::optional<fc::time_point>{},
      trx_st ? std::optional<fc::time_point_sec>(trx_st->expiration) : std::optional<fc::time_point_sec>{},
      chain::block_header::num_from_id(ch_state.head_id),
      ch_state.head_id,
      ch_state.head_block_timestamp,
      chain::block_header::num_from_id(ch_state.irr_id),
      ch_state.irr_id,
      ch_state.irr_block_timestamp,
      ch_state.earliest_tracked_block_id,
      chain::block_header::num_from_id(ch_state.earliest_tracked_block_id)
   };
}

set_shorten_abi_errors()

void sysio::chain_apis::read_only::set_shorten_abi_errors ( bool f )

inline

Definition at line 105 of file chain_plugin.hpp.

{ shorten_abi_errors = f; }

validate()

void sysio::chain_apis::read_only::validate ( ) const

inline

Definition at line 103 of file chain_plugin.hpp.

{}

walk_key_value_table()

template<typename Function >

void sysio::chain_apis::read_only::walk_key_value_table ( const name & code, const name & scope, const name & table, Function f ) const

inline

Definition at line 459 of file chain_plugin.hpp.

   {
      const auto& d = db.db();
      const auto* t_id = d.find<chain::table_id_object, chain::by_code_scope_table>(boost::make_tuple(code, scope, table));
      if (t_id != nullptr) {
         const auto &idx = d.get_index<chain::key_value_index, chain::by_scope_primary>();
         decltype(t_id->id) next_tid(t_id->id._id + 1);
         auto lower = idx.lower_bound(boost::make_tuple(t_id->id));
         auto upper = idx.lower_bound(boost::make_tuple(next_tid));
 
         for (auto itr = lower; itr != upper; ++itr) {
            if (!f(*itr)) {
               break;
            }
         }
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

KEYi64

const string sysio::chain_apis::read_only::KEYi64 = "i64"

static

Definition at line 97 of file chain_plugin.hpp.

---

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