Namespaces
namespace	config

namespace	detail

namespace	eosvmoc

namespace	impl

namespace	legacy

namespace	literals

namespace	plugin_interface

namespace	resource_limits

namespace	wasm_constraints

namespace	wasm_injections

namespace	wasm_ops

namespace	wasm_validations

namespace	webassembly

Classes
struct	abi_def

struct	abi_serializer

struct	account_delta

class	account_metadata_object

class	account_object

class	account_ram_correction_object

struct	action

struct	action_base

struct	action_def

struct	action_notice

struct	action_receipt

struct	action_result_def

struct	action_trace

struct	additional_block_signatures_extension

class	apply_context

struct	assembled_block

struct	asset

struct	authority

class	authority_checker
	namespace detail More...

class	authorization_manager

struct	basic_type_converter

struct	block_header

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

class	block_log

struct	block_log_prune_config

struct	block_signing_authority_v0

struct	block_state

class	block_summary_object
	tracks minimal information about past blocks to implement TaPOS More...

class	block_timestamp

struct	building_block

class	builtin_protocol_feature

struct	builtin_protocol_feature_spec

struct	canceldelay

struct	chain_config_v0
	Producer-voted blockchain configuration parameters. More...

struct	chain_config_v1
	v1 Producer-voted blockchain configuration parameters More...

struct	chain_id_type

struct	chain_snapshot_header

struct	clause_pair

class	code_object

struct	completed_block

struct	config_entry_validator

class	controller

struct	controller_impl

struct	data_entry

struct	data_range

class	database_header_object
	tracks the version of the application data stored in the database More...

class	deep_mind_handler

struct	deferred_transaction_generation_context

struct	deleteauth

class	dynamic_global_property_object
	Maintains global state information that frequently change. More...

class	end_insert_iterator

struct	enum_hash

struct	error_message

struct	extended_asset

struct	extended_symbol

struct	field_def

class	fork_database
	manages light-weight state for all potential unconfirmed forks More...

struct	fork_database_impl

class	generated_transaction

class	generated_transaction_object

struct	genesis_state

class	global_property_object
	Maintains global state information about block producer schedules and chain configuration parameters. More...

class	incremental_merkle_impl
	detail More...

class	index_set

class	index_set< FirstIndex, RemainingIndices... >

class	index_set< Index >

class	index_utils

class	integrity_hash_snapshot_writer

class	istream_snapshot_reader

struct	key_value_object

struct	key_weight

struct	kv_database_config
	limits for a kv database. More...

struct	linkauth

struct	may_not_exist

class	maybe_session

struct	memcmp_params

struct	memcpy_params

struct	memset_params

struct	name
	Immutable except for fc::from_variant. More...

class	named_thread_pool

struct	newaccount

struct	null_terminated_ptr

struct	object_to_table_id_tag

struct	onerror

class	ostream_snapshot_writer

struct	overloaded

struct	packed_transaction

struct	pending_block_header_state

struct	pending_state

struct	permission_level

struct	permission_level_weight

class	permission_link_object
	The permission_link_object class assigns permission_objects to message types. More...

class	permission_object

class	permission_usage_object

struct	platform_timer

struct	producer_authority

struct	producer_authority_schedule

struct	producer_confirmation

struct	producer_schedule_change_extension

struct	protocol_feature

struct	protocol_feature_activation

struct	protocol_feature_activation_set

class	protocol_feature_base

class	protocol_feature_manager

class	protocol_feature_set

struct	protocol_feature_subjective_restrictions

class	protocol_state_object
	Maintains global state information about consensus protocol rules. More...

struct	ram_trace

struct	read_limiter

struct	s_header

struct	s_root_extension

struct	secondary_index

struct	secondary_key_traits

struct	secondary_key_traits< float128_t >

struct	secondary_key_traits< float64_t >

struct	secondary_key_traits< std::array< uint128_t, N > >

struct	setabi

struct	setcode

struct	sha256_less

struct	shared_authority

class	shared_blob

struct	shared_block_signing_authority_v0

struct	shared_key_weight

struct	shared_producer_authority

struct	shared_producer_authority_schedule

struct	shared_public_key

struct	signed_block

struct	signed_block_header

struct	signed_transaction

struct	snapshot_global_property_object

struct	snapshot_permission_object

struct	snapshot_protocol_state_object

class	snapshot_reader

class	snapshot_writer

struct	soft_double_less

struct	soft_long_double_less

struct	struct_def

class	symbol

struct	symbol_code

struct	table_def

class	table_id_object
	The table_id_object class tracks the mapping of (scope, code, table) to an opaque identifier. More...

struct	transaction

struct	transaction_checktime_timer

class	transaction_context

struct	transaction_header

class	transaction_metadata

class	transaction_object

struct	transaction_receipt

struct	transaction_receipt_header

struct	transaction_trace

struct	trim_data

struct	type_def

struct	unapplied_transaction

class	unapplied_transaction_queue

struct	unlinkauth

struct	updateauth

struct	variant_def

class	variant_snapshot_reader

class	variant_snapshot_writer

struct	void_t

struct	wait_weight

struct	wasm_config

struct	wasm_exit

class	wasm_instantiated_module_interface

class	wasm_interface

struct	wasm_interface_impl

class	wasm_runtime_interface

Typedefs
using	authorization_index_set

using	controller_index_set

using	contract_database_index_set

using	block_stage_type = std::variant<building_block, assembled_block, completed_block>

typedef multi_index_container< block_state_ptr, indexed_by< hashed_unique< tag< by_block_id >, member< block_header_state, block_id_type, &block_header_state::id >, std::hash< block_id_type > >, ordered_non_unique< tag< by_prev >, const_mem_fun< block_header_state, const block_id_type &, &block_header_state::prev > >, ordered_unique< tag< by_lib_block_num >, composite_key< block_state, global_fun< const block_state &, bool, &block_state_is_valid >, member< detail::block_header_state_common, uint32_t, &detail::block_header_state_common::dpos_irreversible_blocknum >, member< detail::block_header_state_common, uint32_t, &detail::block_header_state_common::block_num >, member< block_header_state, block_id_type, &block_header_state::id > >, composite_key_compare< std::greater< bool >, std::greater< uint32_t >, std::greater< uint32_t >, sha256_less > > > >	fork_multi_index_type

using	type_name = string

using	field_name = string

using	account_id_type = account_object::id_type

using	account_index

using	account_metadata_index

using	account_ram_correction_index

using	apply_handler = std::function<void(apply_context&)>

using	shared_public_key_data = std::variant<fc::ecc::public_key_shim, fc::crypto::r1::public_key_shim, shared_string, fc::em::public_key_shim>

using	block_extension_types

using	block_extension = block_extension_types::block_extension_t

using	signed_block_ptr = std::shared_ptr<signed_block>

using	block_header_extension_types

using	block_header_extension = block_header_extension_types::block_header_extension_t

using	signer_callback_type = std::function<std::vector<signature_type>(const digest_type&)>

using	block_header_state_ptr = std::shared_ptr<block_header_state>

using	block_state_ptr = std::shared_ptr<block_state>

using	branch_type = deque<block_state_ptr>

using	block_summary_multi_index

typedef block_timestamp< config::block_interval_ms, config::block_timestamp_epoch >	block_timestamp_type

using	chain_config = chain_config_v1

using	config_range = data_range<chain_config, config_entry_validator>

using	code_index

using	table_id_multi_index

using	table_id = table_id_object::id_type

using	key_value_index

typedef secondary_index< uint64_t, index64_object_type >::index_object	index64_object

typedef secondary_index< uint64_t, index64_object_type >::index_index	index64_index

typedef secondary_index< uint128_t, index128_object_type >::index_object	index128_object

typedef secondary_index< uint128_t, index128_object_type >::index_index	index128_index

typedef std::array< uint128_t, 2 >	key256_t

typedef secondary_index< key256_t, index256_object_type >::index_object	index256_object

typedef secondary_index< key256_t, index256_object_type >::index_index	index256_index

typedef secondary_index< float64_t, index_double_object_type, soft_double_less >::index_object	index_double_object

typedef secondary_index< float64_t, index_double_object_type, soft_double_less >::index_index	index_double_index

typedef secondary_index< float128_t, index_long_double_object_type, soft_long_double_less >::index_object	index_long_double_object

typedef secondary_index< float128_t, index_long_double_object_type, soft_long_double_less >::index_index	index_long_double_index

template<typename T >
using	object_to_table_id_tag_t = typename object_to_table_id_tag<T>::tag_type

using	action_name = sysio::chain::action_name

using	forked_branch_callback = std::function<void(const branch_type&)>

using	trx_meta_cache_lookup = std::function<transaction_metadata_ptr( const transaction_id_type&)>

using	database_header_multi_index

using	generated_transaction_multi_index

using	global_property_multi_index

using	dynamic_global_property_multi_index

typedef incremental_merkle_impl< digest_type >	incremental_merkle

typedef incremental_merkle_impl< digest_type, shared_vector >	shared_incremental_merkle

using	permission_link_index

using	permission_usage_index

using	permission_index

using	shared_block_signing_authority = std::variant<shared_block_signing_authority_v0>

using	block_signing_authority = std::variant<block_signing_authority_v0>

using	protocol_feature_activation_set_ptr = std::shared_ptr<protocol_feature_activation_set>

using	protocol_state_multi_index

using	snapshot_writer_ptr = std::shared_ptr<snapshot_writer>

using	snapshot_reader_ptr = std::shared_ptr<snapshot_reader>

using	transaction_trace_ptr = std::shared_ptr<transaction_trace>

using	transaction_extension_types

using	transaction_extension = transaction_extension_types::transaction_extension_t

using	packed_transaction_ptr = std::shared_ptr<const packed_transaction>

using	transaction_metadata_ptr = std::shared_ptr<transaction_metadata>

using	recover_keys_future = std::future<transaction_metadata_ptr>

using	transaction_multi_index

typedef chainbase::generic_index< transaction_multi_index >	transaction_index

using	public_key_type = fc::crypto::public_key

using	private_key_type = fc::crypto::private_key

using	signature_type = fc::crypto::signature

using	shared_string = chainbase::shared_string

template<typename T >
using	shared_vector = boost::interprocess::vector<T, allocator<T>>

template<typename T >
using	shared_set = boost::interprocess::set<T, std::less<T>, allocator<T>>

template<typename K , typename V >
using	shared_flat_multimap = boost::interprocess::flat_multimap< K, V, std::less<K>, allocator< std::pair<K,V> > >

using	scope_name = name

using	account_name = name

using	permission_name = name

using	table_name = name

using	block_id_type = fc::sha256

using	checksum_type = fc::sha256

using	checksum256_type = fc::sha256

using	checksum512_type = fc::sha512

using	checksum160_type = fc::ripemd160

using	transaction_id_type = checksum_type

using	digest_type = checksum_type

using	weight_type = uint16_t

using	block_num_type = uint32_t

using	share_type = int64_t

using	int128_t = __int128

using	uint128_t = unsigned __int128

using	bytes = vector<char>

typedef vector< std::pair< uint16_t, vector< char > > >	extensions_type

using	next_func_t = std::function<void(const std::variant<fc::exception_ptr, transaction_trace_ptr>&)>

template<typename T , std::size_t Extent = sysio::vm::dynamic_extent>
using	span = sysio::vm::span<T, Extent>

template<typename T , std::size_t Align = alignof(T)>
using	legacy_ptr = sysio::vm::argument_proxy<T*, Align>

template<typename T , std::size_t Align = alignof(T)>
using	legacy_span = sysio::vm::argument_proxy<sysio::vm::span<T>, Align>

using	type_converter = basic_type_converter<sysio::vm::execution_interface>

using	eos_vm_host_functions_t

using	wasm_size_t = sysio::vm::wasm_size_t

template<typename Impl >
using	eos_vm_backend_t = sysio::vm::backend<eos_vm_host_functions_t, Impl, webassembly::eos_vm_runtime::apply_options, vm::profile_instr_map>

template<typename Options >
using	eos_vm_null_backend_t = sysio::vm::backend<eos_vm_host_functions_t, sysio::vm::null_backend, Options>

using	whitelisted_intrinsics_type = shared_flat_multimap<uint64_t, shared_string>

Enumerations
enum class	db_read_mode { SPECULATIVE , HEAD , READ_ONLY , IRREVERSIBLE }

enum class	validation_mode { FULL , LIGHT }

enum class	system_error_code : uint64_t { generic_system_error = 10000000000000000000ULL , contract_restricted_error_code }

enum class	protocol_feature_t : uint32_t { builtin }

enum class	builtin_protocol_feature_t : uint32_t { preactivate_feature = 0 , only_link_to_existing_permission = 1 , replace_deferred = 2 , no_duplicate_deferred_id = 3 , fix_linkauth_restriction = 4 , disallow_empty_producer_schedule = 5 , restrict_action_to_self = 6 , only_bill_first_authorizer = 7 , forward_setcode = 8 , get_sender = 9 , ram_restrictions = 10 , webauthn_key = 11 , wtmsig_block_signatures = 12 , action_return_value = 13 , blockchain_parameters = 16 , get_code_hash = 17 , configurable_wasm_limits = 18 , crypto_primitives = 19 , get_block_num = 20 , em_key = 21 , reserved_private_fork_protocol_features = 500000 }

enum	object_type { null_object_type = 0 , account_object_type , account_metadata_object_type , permission_object_type , permission_usage_object_type , permission_link_object_type , UNUSED_action_code_object_type , key_value_object_type , index64_object_type , index128_object_type , index256_object_type , index_double_object_type , index_long_double_object_type , global_property_object_type , dynamic_global_property_object_type , block_summary_object_type , transaction_object_type , generated_transaction_object_type , UNUSED_producer_object_type , UNUSED_chain_property_object_type , account_control_history_object_type , UNUSED_account_transaction_history_object_type , UNUSED_transaction_history_object_type , public_key_history_object_type , UNUSED_balance_object_type , UNUSED_staked_balance_object_type , UNUSED_producer_votes_object_type , UNUSED_producer_schedule_object_type , UNUSED_proxy_vote_object_type , UNUSED_scope_sequence_object_type , table_id_object_type , resource_limits_object_type , resource_usage_object_type , resource_limits_state_object_type , resource_limits_config_object_type , account_history_object_type , action_history_object_type , reversible_block_object_type , protocol_state_object_type , account_ram_correction_object_type , code_object_type , database_header_object_type , OBJECT_TYPE_COUNT }

enum class	trx_enum_type { unknown = 0 , persisted = 1 , forked = 2 , aborted = 3 , incoming_persisted = 4 , incoming = 5 }

Functions
template<typename T >
fc::variant	variant_from_stream (fc::datastream< const char * > &stream)

template<typename T >
fc::variant	variant_from_stream (fc::datastream< const char * > &stream, const abi_serializer::yield_function_t &yield)

template<typename T >
auto	pack_function ()

template<typename T >
auto	pack_unpack ()

template<typename T >
auto	pack_unpack_deadline ()

void	noop_checktime ()

template<>
void	controller_impl::on_activation< builtin_protocol_feature_t::preactivate_feature > ()
	Protocol feature activation handlers:

template<>
void	controller_impl::on_activation< builtin_protocol_feature_t::get_sender > ()

template<>
void	controller_impl::on_activation< builtin_protocol_feature_t::replace_deferred > ()

template<>
void	controller_impl::on_activation< builtin_protocol_feature_t::webauthn_key > ()

template<>
void	controller_impl::on_activation< builtin_protocol_feature_t::em_key > ()

template<>
void	controller_impl::on_activation< builtin_protocol_feature_t::wtmsig_block_signatures > ()

template<>
void	controller_impl::on_activation< builtin_protocol_feature_t::action_return_value > ()

template<>
void	controller_impl::on_activation< builtin_protocol_feature_t::configurable_wasm_limits > ()

template<>
void	controller_impl::on_activation< builtin_protocol_feature_t::blockchain_parameters > ()

template<>
void	controller_impl::on_activation< builtin_protocol_feature_t::get_code_hash > ()

template<>
void	controller_impl::on_activation< builtin_protocol_feature_t::get_block_num > ()

template<>
void	controller_impl::on_activation< builtin_protocol_feature_t::crypto_primitives > ()

bool	block_state_is_valid (const block_state &bs)

bool	first_preferred (const block_header_state &lhs, const block_header_state &rhs)

abi_def	sysio_contract_abi (const abi_def &sysio_system_abi)

vector< type_def >	common_type_defs ()

	FC_RETHROW_EXCEPTIONS (error, "Failed to serialize: ${type}",("type", boost::core::demangle(typeid(o).name()))) template< typename T

	FC_RETHROW_EXCEPTIONS (error, "Failed to deserialize variant",("variant", v)) template< typename T

bool	operator== (const permission_level &lhs, const permission_level &rhs)

bool	operator!= (const permission_level &lhs, const permission_level &rhs)

bool	operator< (const permission_level &lhs, const permission_level &rhs)

bool	operator<= (const permission_level &lhs, const permission_level &rhs)

bool	operator> (const permission_level &lhs, const permission_level &rhs)

bool	operator>= (const permission_level &lhs, const permission_level &rhs)

template<typename Hasher >
auto	generate_action_digest (Hasher &&hash, const action &act, const vector< char > &action_output)

bool	operator< (const asset &a, const asset &b)

bool	operator<= (const asset &a, const asset &b)

template<typename Authority >
bool	validate (const Authority &auth)

template<typename PermissionToAuthorityFunc >
auto	make_auth_checker (PermissionToAuthorityFunc &&pta, uint16_t recursion_depth_limit, const flat_set< public_key_type > &provided_keys, const flat_set< permission_level > &provided_permissions=flat_set< permission_level >(), fc::microseconds provided_delay=fc::microseconds(0), const std::function< void()> &_checktime=std::function< void()>())
	authority_checker

template<typename DataStream >
DataStream &	operator<< (DataStream &ds, const shared_blob &b)

template<typename DataStream >
DataStream &	operator>> (DataStream &ds, shared_blob &b)

	FC_DECLARE_DERIVED_EXCEPTION_WITH_ERROR_CODE (chain_exception, fc::exception, 3000000, "blockchain exception") FC_DECLARE_DERIVED_EXCEPTION(chain_type_exception

chain type exception	FC_DECLARE_DERIVED_EXCEPTION (name_type_exception, chain_type_exception, 3010001, "Invalid name") FC_DECLARE_DERIVED_EXCEPTION(public_key_type_exception

key	FC_DECLARE_DERIVED_EXCEPTION (private_key_type_exception, chain_type_exception, 3010003, "Invalid private key") FC_DECLARE_DERIVED_EXCEPTION(authority_type_exception

key Invalid authority	FC_DECLARE_DERIVED_EXCEPTION (action_type_exception, chain_type_exception, 3010005, "Invalid action") FC_DECLARE_DERIVED_EXCEPTION(transaction_type_exception

key Invalid authority Invalid transaction	FC_DECLARE_DERIVED_EXCEPTION (abi_type_exception, chain_type_exception, 3010007, "Invalid ABI") FC_DECLARE_DERIVED_EXCEPTION(block_id_type_exception

key Invalid authority Invalid transaction Invalid block ID	FC_DECLARE_DERIVED_EXCEPTION (transaction_id_type_exception, chain_type_exception, 3010009, "Invalid transaction ID") FC_DECLARE_DERIVED_EXCEPTION(packed_transaction_type_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction	FC_DECLARE_DERIVED_EXCEPTION (asset_type_exception, chain_type_exception, 3010011, "Invalid asset") FC_DECLARE_DERIVED_EXCEPTION(chain_id_type_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID	FC_DECLARE_DERIVED_EXCEPTION (fixed_key_type_exception, chain_type_exception, 3010013, "Invalid fixed key") FC_DECLARE_DERIVED_EXCEPTION(symbol_type_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol	FC_DECLARE_DERIVED_EXCEPTION (unactivated_key_type, chain_type_exception, 3010015, "Key type is not a currently activated type") FC_DECLARE_DERIVED_EXCEPTION(unactivated_signature_type

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type	FC_DECLARE_DERIVED_EXCEPTION (fork_database_exception, chain_exception, 3020000, "Fork database exception") FC_DECLARE_DERIVED_EXCEPTION(fork_db_block_not_found

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found	FC_DECLARE_DERIVED_EXCEPTION (block_validate_exception, chain_exception, 3030000, "Block exception") FC_DECLARE_DERIVED_EXCEPTION(unlinkable_block_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block	FC_DECLARE_DERIVED_EXCEPTION (block_tx_output_exception, block_validate_exception, 3030002, "Transaction outputs in block do not match transaction outputs from applying block") FC_DECLARE_DERIVED_EXCEPTION(block_concurrency_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts	FC_DECLARE_DERIVED_EXCEPTION (block_lock_exception, block_validate_exception, 3030004, "Shard locks in block are incorrect or mal-formed") FC_DECLARE_DERIVED_EXCEPTION(block_resource_exhausted

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources	FC_DECLARE_DERIVED_EXCEPTION (block_too_old_exception, block_validate_exception, 3030006, "Block is too old to push") FC_DECLARE_DERIVED_EXCEPTION(block_from_the_future

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future	FC_DECLARE_DERIVED_EXCEPTION (wrong_signing_key, block_validate_exception, 3030008, "Block is not signed with expected key") FC_DECLARE_DERIVED_EXCEPTION(wrong_producer

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer	FC_DECLARE_DERIVED_EXCEPTION (invalid_block_header_extension, block_validate_exception, 3030010, "Invalid block header extension") FC_DECLARE_DERIVED_EXCEPTION(ill_formed_protocol_feature_activation

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension	FC_DECLARE_DERIVED_EXCEPTION (invalid_block_extension, block_validate_exception, 3030012, "Invalid block extension") FC_DECLARE_DERIVED_EXCEPTION(ill_formed_additional_block_signatures_extension

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension	FC_DECLARE_DERIVED_EXCEPTION (transaction_exception, chain_exception, 3040000, "Transaction exception") FC_DECLARE_DERIVED_EXCEPTION(tx_decompression_error

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction	FC_DECLARE_DERIVED_EXCEPTION (tx_no_action, transaction_exception, 3040002, "Transaction should have at least one normal action") FC_DECLARE_DERIVED_EXCEPTION(tx_no_auths

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority	FC_DECLARE_DERIVED_EXCEPTION (cfa_irrelevant_auth, transaction_exception, 3040004, "Context-free action should have no required authority") FC_DECLARE_DERIVED_EXCEPTION(expired_tx_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction	FC_DECLARE_DERIVED_EXCEPTION (tx_exp_too_far_exception, transaction_exception, 3040006, "Transaction Expiration Too Far") FC_DECLARE_DERIVED_EXCEPTION(invalid_ref_block_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block	FC_DECLARE_DERIVED_EXCEPTION (tx_duplicate, transaction_exception, 3040008, "Duplicate transaction") FC_DECLARE_DERIVED_EXCEPTION(deferred_tx_duplicate

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction	FC_DECLARE_DERIVED_EXCEPTION (cfa_inside_generated_tx, transaction_exception, 3040010, "Context free action is not allowed inside generated transaction") FC_DECLARE_DERIVED_EXCEPTION(tx_not_found

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found	FC_DECLARE_DERIVED_EXCEPTION (too_many_tx_at_once, transaction_exception, 3040012, "Pushing too many transactions at once") FC_DECLARE_DERIVED_EXCEPTION(tx_too_big

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big	FC_DECLARE_DERIVED_EXCEPTION (unknown_transaction_compression, transaction_exception, 3040014, "Unknown transaction compression") FC_DECLARE_DERIVED_EXCEPTION(invalid_transaction_extension

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension	FC_DECLARE_DERIVED_EXCEPTION (ill_formed_deferred_transaction_generation_context, transaction_exception, 3040016, "Transaction includes an ill-formed deferred transaction generation context extension") FC_DECLARE_DERIVED_EXCEPTION(disallowed_transaction_extensions_bad_block_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed	extensions (invalid block)" ) FC_DECLARE_DERIVED_EXCEPTION( tx_resource_exhaustion

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit	FC_DECLARE_DERIVED_EXCEPTION (action_validate_exception, chain_exception, 3050000, "Action validate exception") FC_DECLARE_DERIVED_EXCEPTION(account_name_exists_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists	FC_DECLARE_DERIVED_EXCEPTION (invalid_action_args_exception, action_validate_exception, 3050002, "Invalid Action Arguments") FC_DECLARE_DERIVED_EXCEPTION(sysio_assert_message_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure	FC_DECLARE_DERIVED_EXCEPTION (sysio_assert_code_exception, action_validate_exception, 3050004, "sysio_assert_code assertion failure") FC_DECLARE_DERIVED_EXCEPTION(action_not_found_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found	FC_DECLARE_DERIVED_EXCEPTION (action_data_and_struct_mismatch, action_validate_exception, 3050006, "Mismatch between action data and its struct") FC_DECLARE_DERIVED_EXCEPTION(unaccessible_api

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API	FC_DECLARE_DERIVED_EXCEPTION (abort_called, action_validate_exception, 3050008, "Abort Called") FC_DECLARE_DERIVED_EXCEPTION(inline_action_too_big

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit	FC_DECLARE_DERIVED_EXCEPTION (unauthorized_ram_usage_increase, action_validate_exception, 3050010, "Action attempts to increase RAM usage of account without authorization") FC_DECLARE_DERIVED_EXCEPTION(restricted_error_code_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value	FC_DECLARE_DERIVED_EXCEPTION (inline_action_too_big_nonprivileged, action_validate_exception, 3050012, "Inline action exceeds maximum size limit for a non-privileged account") FC_DECLARE_DERIVED_EXCEPTION(action_return_value_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big	FC_DECLARE_DERIVED_EXCEPTION (database_exception, chain_exception, 3060000, "Database exception") FC_DECLARE_DERIVED_EXCEPTION(permission_query_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception	FC_DECLARE_DERIVED_EXCEPTION (account_query_exception, database_exception, 3060002, "Account Query Exception") FC_DECLARE_DERIVED_EXCEPTION(contract_table_query_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception	FC_DECLARE_DERIVED_EXCEPTION (contract_query_exception, database_exception, 3060004, "Contract Query Exception") FC_DECLARE_DERIVED_EXCEPTION(bad_database_version_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version	FC_DECLARE_DERIVED_EXCEPTION (guard_exception, database_exception, 3060100, "Guard Exception") FC_DECLARE_DERIVED_EXCEPTION(database_guard_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version Database usage is at unsafe levels	FC_DECLARE_DERIVED_EXCEPTION (wasm_exception, chain_exception, 3070000, "WASM Exception") FC_DECLARE_DERIVED_EXCEPTION(page_memory_error

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version Database usage is at unsafe levels Error in WASM page memory	FC_DECLARE_DERIVED_EXCEPTION (wasm_execution_error, wasm_exception, 3070002, "Runtime Error Processing WASM") FC_DECLARE_DERIVED_EXCEPTION(wasm_serialization_error

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version Database usage is at unsafe levels Error in WASM page memory Serialization Error Processing WASM	FC_DECLARE_DERIVED_EXCEPTION (overlapping_memory_error, wasm_exception, 3070004, "memcpy with overlapping memory") FC_DECLARE_DERIVED_EXCEPTION(binaryen_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version Database usage is at unsafe levels Error in WASM page memory Serialization Error Processing WASM binaryen exception	FC_DECLARE_DERIVED_EXCEPTION (resource_exhausted_exception, chain_exception, 3080000, "Resource exhausted exception") FC_DECLARE_DERIVED_EXCEPTION(ram_usage_exceeded

bool	operator== (const kv_database_config &lhs, const kv_database_config &rhs)

bool	operator!= (const kv_database_config &lhs, const kv_database_config &rhs)

digest_type	make_canonical_left (const digest_type &val)

digest_type	make_canonical_right (const digest_type &val)

bool	is_canonical_left (const digest_type &val)

bool	is_canonical_right (const digest_type &val)

auto	make_canonical_pair (const digest_type &l, const digest_type &r)

digest_type	merkle (vector< digest_type > ids)

constexpr uint64_t	char_to_symbol (char c)

constexpr uint64_t	string_to_uint64_t (std::string_view str)

constexpr name	string_to_name (std::string_view str)

template<typename T , T... Str>
constexpr name	operator""_n ()

template<typename DataRange , typename MarkerRange , typename Marker >
DataRange	filter_data_by_marker (DataRange data, MarkerRange markers, const Marker &markerValue)
	Return values in DataRange corresponding to matching Markers.

void	compute_and_print_timer_accuracy (platform_timer &t)

bool	operator== (const producer_authority &pa, const shared_producer_authority &pb)

const char *	builtin_protocol_feature_codename (builtin_protocol_feature_t)

bool	operator== (const symbol &lhs, const symbol &rhs)

bool	operator!= (const symbol &lhs, const symbol &rhs)

bool	operator< (const symbol &lhs, const symbol &rhs)

bool	operator> (const symbol &lhs, const symbol &rhs)

void	apply_sysio_newaccount (apply_context &)

void	apply_sysio_updateauth (apply_context &)

void	apply_sysio_deleteauth (apply_context &)

void	apply_sysio_linkauth (apply_context &)

void	apply_sysio_unlinkauth (apply_context &)

void	apply_sysio_setcode (apply_context &)

void	apply_sysio_setabi (apply_context &)

void	apply_sysio_canceldelay (apply_context &)

template<typename F >
auto	async_thread_pool (boost::asio::io_context &thread_pool, F &&f)

bool	is_onblock (const transaction_trace &tt)

uint128_t	transaction_id_to_sender_id (const transaction_id_type &tid)

auto	emplace_extension (extensions_type &exts, uint16_t eid, vector< char > &&data)

template<typename Container >
end_insert_iterator< Container >	end_inserter (Container &c)

template<class... Ts>
	overloaded (Ts...) -> overloaded< Ts... >

constexpr bool	operator== (const wasm_config &lhs, const wasm_config &rhs)

constexpr bool	operator!= (const wasm_config &lhs, const wasm_config &rhs)

std::istream &	operator>> (std::istream &in, wasm_interface::vm_type &runtime)

std::vector< uint8_t >	wast_to_wasm (const std::string &wast)

bool	is_intrinsic_whitelisted (const whitelisted_intrinsics_type &whitelisted_intrinsics, std::string_view name)

void	add_intrinsic_to_whitelist (whitelisted_intrinsics_type &whitelisted_intrinsics, std::string_view name)

void	remove_intrinsic_from_whitelist (whitelisted_intrinsics_type &whitelisted_intrinsics, std::string_view name)

void	reset_intrinsic_whitelist (whitelisted_intrinsics_type &whitelisted_intrinsics, const std::set< std::string > &s)

std::set< std::string >	convert_intrinsic_whitelist_to_set (const whitelisted_intrinsics_type &whitelisted_intrinsics)

void	validate_authority_precondition (const apply_context &context, const authority &auth)

template<typename Iterator >
bool	find_intrinsic_helper (uint64_t h, std::string_view name, Iterator &itr, const Iterator &end)

whitelisted_intrinsics_type::iterator	find_intrinsic (whitelisted_intrinsics_type &whitelisted_intrinsics, uint64_t h, std::string_view name)

whitelisted_intrinsics_type::const_iterator	find_intrinsic (const whitelisted_intrinsics_type &whitelisted_intrinsics, uint64_t h, std::string_view name)

std::ostream &	operator<< (std::ostream &osm, sysio::chain::db_read_mode m)

void	validate (boost::any &v, const std::vector< std::string > &values, sysio::chain::db_read_mode *, int)

std::ostream &	operator<< (std::ostream &osm, sysio::chain::validation_mode m)

void	validate (boost::any &v, const std::vector< std::string > &values, sysio::chain::validation_mode *, int)

bool	operator== (const abi_def &lhs, const abi_def &rhs)

bool	operator!= (const abi_def &lhs, const abi_def &rhs)

std::ostream &	operator<< (std::ostream &os, const abi_def &abi)

Variables
const std::vector< const char * >	genesis_intrinsics

unsigned char	sysio_abi_bin [2132]

	chain_exception

chain type exception	chain_type_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type	fork_database_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found	block_validate_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension	transaction_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit	action_validate_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big	database_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version	guard_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version Database usage is at unsafe levels	wasm_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version Database usage is at unsafe levels Error in WASM page memory Serialization Error Processing WASM binaryen exception	resource_exhausted_exception

const std::unordered_map< builtin_protocol_feature_t, builtin_protocol_feature_spec, enum_hash< builtin_protocol_feature_t > >	builtin_protocol_feature_codenames

Typedef Documentation

◆ account_id_type

using sysio::chain::account_id_type = account_object::id_type

Definition at line 36 of file account_object.hpp.

◆ account_index

using sysio::chain::account_index

Initial value:

 chainbase::shared_multi_index_container<
      account_object,
      indexed_by<
         ordered_unique<tag<by_id>, member<account_object, account_object::id_type, &account_object::id>>,
         ordered_unique<tag<by_name>, member<account_object, account_name, &account_object::name>>
      >
   >

Definition at line 39 of file account_object.hpp.

◆ account_metadata_index

using sysio::chain::account_metadata_index

Initial value:

 chainbase::shared_multi_index_container<
      account_metadata_object,
      indexed_by<
         ordered_unique<tag<by_id>, member<account_metadata_object, account_metadata_object::id_type, &account_metadata_object::id>>,
         ordered_unique<tag<by_name>, member<account_metadata_object, account_name, &account_metadata_object::name>>
      >
   >

Definition at line 75 of file account_object.hpp.

◆ account_name

using sysio::chain::account_name = name

Definition at line 120 of file types.hpp.

◆ account_ram_correction_index

using sysio::chain::account_ram_correction_index

Initial value:

 chainbase::shared_multi_index_container<
      account_ram_correction_object,
      indexed_by<
         ordered_unique<tag<by_id>, member<account_ram_correction_object, account_ram_correction_object::id_type, &account_ram_correction_object::id>>,
         ordered_unique<tag<by_name>, member<account_ram_correction_object, account_name, &account_ram_correction_object::name>>
      >
   >

Definition at line 93 of file account_object.hpp.

◆ action_name

typedef name sysio::chain::action_name = sysio::chain::action_name

Definition at line 8 of file contract_types.hpp.

◆ apply_handler

typedef std::function< void(apply_context &)> sysio::chain::apply_handler = std::function<void(apply_context&)>

Definition at line 635 of file apply_context.hpp.

◆ authorization_index_set

using sysio::chain::authorization_index_set

Initial value:

 index_set<
      permission_index,
      permission_usage_index,
      permission_link_index
   >

Definition at line 18 of file authorization_manager.cpp.

◆ block_extension

using sysio::chain::block_extension = block_extension_types::block_extension_t

Definition at line 85 of file block.hpp.

◆ block_extension_types

using sysio::chain::block_extension_types

Initial value:

 detail::block_extension_types<
         additional_block_signatures_extension
   >

Definition at line 81 of file block.hpp.

◆ block_header_extension

using sysio::chain::block_header_extension = block_header_extension_types::block_header_extension_t

Definition at line 24 of file block_header.hpp.

◆ block_header_extension_types

using sysio::chain::block_header_extension_types

Initial value:

 detail::block_header_extension_types<
      protocol_feature_activation, 
      producer_schedule_change_extension, 
      s_root_extension 
   >

Definition at line 18 of file block_header.hpp.

◆ block_header_state_ptr

using sysio::chain::block_header_state_ptr = std::shared_ptr<block_header_state>

Definition at line 160 of file block_header_state.hpp.

◆ block_id_type

using sysio::chain::block_id_type = fc::sha256

Definition at line 231 of file types.hpp.

◆ block_num_type

using sysio::chain::block_num_type = uint32_t

Definition at line 239 of file types.hpp.

◆ block_signing_authority

using sysio::chain::block_signing_authority = std::variant<block_signing_authority_v0>

Definition at line 161 of file producer_schedule.hpp.

◆ block_stage_type

using sysio::chain::block_stage_type = std::variant<building_block, assembled_block, completed_block>

Definition at line 145 of file controller.cpp.

◆ block_state_ptr

using sysio::chain::block_state_ptr = std::shared_ptr<block_state>

Definition at line 67 of file block_state.hpp.

◆ block_summary_multi_index

using sysio::chain::block_summary_multi_index

Initial value:

 chainbase::shared_multi_index_container<
      block_summary_object,
      indexed_by<
         ordered_unique<tag<by_id>, BOOST_MULTI_INDEX_MEMBER(block_summary_object, block_summary_object::id_type, id)>
   
      >
   >

Definition at line 25 of file block_summary_object.hpp.

◆ block_timestamp_type

typedef block_timestamp<config::block_interval_ms,config::block_timestamp_epoch> sysio::chain::block_timestamp_type

Definition at line 75 of file block_timestamp.hpp.

◆ branch_type

using sysio::chain::branch_type = deque<block_state_ptr>

Definition at line 68 of file block_state.hpp.

◆ bytes

using sysio::chain::bytes = vector<char>

Definition at line 243 of file types.hpp.

◆ chain_config

using sysio::chain::chain_config = chain_config_v1

Definition at line 196 of file chain_config.hpp.

◆ checksum160_type

using sysio::chain::checksum160_type = fc::ripemd160

Definition at line 235 of file types.hpp.

◆ checksum256_type

using sysio::chain::checksum256_type = fc::sha256

Definition at line 233 of file types.hpp.

◆ checksum512_type

using sysio::chain::checksum512_type = fc::sha512

Definition at line 234 of file types.hpp.

◆ checksum_type

using sysio::chain::checksum_type = fc::sha256

Definition at line 232 of file types.hpp.

◆ code_index

using sysio::chain::code_index

Initial value:

 chainbase::shared_multi_index_container<
      code_object,
      indexed_by<
         ordered_unique<tag<by_id>, member<code_object, code_object::id_type, &code_object::id>>,
         ordered_unique<tag<by_code_hash>,
            composite_key< code_object,
               member<code_object, digest_type, &code_object::code_hash>,
               member<code_object, uint8_t,     &code_object::vm_type>,
               member<code_object, uint8_t,     &code_object::vm_version>
            >
         >
      >
   >

Definition at line 22 of file code_object.hpp.

◆ config_range

using sysio::chain::config_range = data_range<chain_config, config_entry_validator>

Definition at line 197 of file chain_config.hpp.

◆ contract_database_index_set

using sysio::chain::contract_database_index_set

Initial value:

 index_set<
   key_value_index,
   index64_index,
   index128_index,
   index256_index,
   index_double_index,
   index_long_double_index
>

Definition at line 57 of file controller.cpp.

◆ controller_index_set

using sysio::chain::controller_index_set

Initial value:

 index_set<
   account_index,
   account_metadata_index,
   account_ram_correction_index,
   global_property_multi_index,
   protocol_state_multi_index,
   dynamic_global_property_multi_index,
   block_summary_multi_index,
   transaction_multi_index,
   generated_transaction_multi_index,
   table_id_multi_index,
   code_index,
   database_header_multi_index
>

Definition at line 42 of file controller.cpp.

◆ database_header_multi_index

using sysio::chain::database_header_multi_index

Initial value:

 chainbase::shared_multi_index_container<
            database_header_object,
            indexed_by<
                  ordered_unique<tag<by_id>, BOOST_MULTI_INDEX_MEMBER(database_header_object, database_header_object::id_type, id)>
             >
      >

Definition at line 43 of file database_header_object.hpp.

◆ digest_type

using sysio::chain::digest_type = checksum_type

Definition at line 237 of file types.hpp.

◆ dynamic_global_property_multi_index

using sysio::chain::dynamic_global_property_multi_index

Initial value:

 chainbase::shared_multi_index_container<
      dynamic_global_property_object,
      indexed_by<
         ordered_unique<tag<by_id>,
 
         >
      >
   >

Definition at line 158 of file global_property_object.hpp.

◆ eos_vm_backend_t

template<typename Impl >

using sysio::chain::eos_vm_backend_t = sysio::vm::backend<eos_vm_host_functions_t, Impl, webassembly::eos_vm_runtime::apply_options, vm::profile_instr_map>

Definition at line 22 of file sys-vm.hpp.

◆ eos_vm_host_functions_t

using sysio::chain::eos_vm_host_functions_t

Initial value:

 sysio::vm::registered_host_functions<webassembly::interface,
                                                                        sysio::vm::execution_interface,
                                                                        sysio::chain::type_converter>

Definition at line 118 of file common.hpp.

◆ eos_vm_null_backend_t

template<typename Options >

using sysio::chain::eos_vm_null_backend_t = sysio::vm::backend<eos_vm_host_functions_t, sysio::vm::null_backend, Options>

Definition at line 25 of file sys-vm.hpp.

◆ extensions_type

typedef vector<std::pair<uint16_t,vector<char> > > sysio::chain::extensions_type

Extentions are prefixed with type and are a buffer that can be interpreted by code that is aware and ignored by unaware code.

Definition at line 258 of file types.hpp.

◆ field_name

using sysio::chain::field_name = string

Definition at line 8 of file abi_def.hpp.

◆ fork_multi_index_type

typedef multi_index_container< block_state_ptr, indexed_by< hashed_unique< tag<by_block_id>, member<block_header_state, block_id_type, &block_header_state::id>, std::hash<block_id_type> >, ordered_non_unique< tag<by_prev>, const_mem_fun<block_header_state, const block_id_type&, &block_header_state::prev> >, ordered_unique< tag<by_lib_block_num>, composite_key< block_state, global_fun<const block_state&, bool, &block_state_is_valid>, member<detail::block_header_state_common, uint32_t, &detail::block_header_state_common::dpos_irreversible_blocknum>, member<detail::block_header_state_common, uint32_t, &detail::block_header_state_common::block_num>, member<block_header_state, block_id_type, &block_header_state::id> >, composite_key_compare< std::greater<bool>, std::greater<uint32_t>, std::greater<uint32_t>, sha256_less > > > > sysio::chain::fork_multi_index_type

Definition at line 56 of file fork_database.cpp.

◆ forked_branch_callback

using sysio::chain::forked_branch_callback = std::function<void(const branch_type&)>

Definition at line 45 of file controller.hpp.

◆ generated_transaction_multi_index

using sysio::chain::generated_transaction_multi_index

Initial value:

 chainbase::shared_multi_index_container<
      generated_transaction_object,
      indexed_by<
         ordered_unique< tag<by_id>, BOOST_MULTI_INDEX_MEMBER(generated_transaction_object, generated_transaction_object::id_type, id)>,
         ordered_unique< tag<by_trx_id>, BOOST_MULTI_INDEX_MEMBER( generated_transaction_object, transaction_id_type, trx_id)>,
         ordered_unique< tag<by_expiration>,
            composite_key< generated_transaction_object,
               BOOST_MULTI_INDEX_MEMBER( generated_transaction_object, time_point, expiration),
 
            >
         >,
         ordered_unique< tag<by_delay>,
            composite_key< generated_transaction_object,
               BOOST_MULTI_INDEX_MEMBER( generated_transaction_object, time_point, delay_until),
 
            >
         >,
         ordered_unique< tag<by_sender_id>,
            composite_key< generated_transaction_object,
               BOOST_MULTI_INDEX_MEMBER( generated_transaction_object, account_name, sender),
 
            >
         >
      >
   >

Definition at line 52 of file generated_transaction_object.hpp.

◆ global_property_multi_index

using sysio::chain::global_property_multi_index

Initial value:

 chainbase::shared_multi_index_container<
      global_property_object,
      indexed_by<
         ordered_unique<tag<by_id>,
 
         >
      >
   >

Definition at line 105 of file global_property_object.hpp.

◆ incremental_merkle

typedef incremental_merkle_impl<digest_type> sysio::chain::incremental_merkle

Definition at line 246 of file incremental_merkle.hpp.

◆ index128_index

typedef secondary_index<uint128_t,index128_object_type>::index_index sysio::chain::index128_index

Definition at line 123 of file contract_table_objects.hpp.

◆ index128_object

typedef secondary_index<uint128_t,index128_object_type>::index_object sysio::chain::index128_object

Definition at line 122 of file contract_table_objects.hpp.

◆ index256_index

typedef secondary_index<key256_t,index256_object_type>::index_index sysio::chain::index256_index

Definition at line 127 of file contract_table_objects.hpp.

◆ index256_object

typedef secondary_index<key256_t,index256_object_type>::index_object sysio::chain::index256_object

Definition at line 126 of file contract_table_objects.hpp.

◆ index64_index

typedef secondary_index<uint64_t,index64_object_type>::index_index sysio::chain::index64_index

Definition at line 120 of file contract_table_objects.hpp.

◆ index64_object

typedef secondary_index<uint64_t,index64_object_type>::index_object sysio::chain::index64_object

Definition at line 119 of file contract_table_objects.hpp.

◆ index_double_index

typedef secondary_index<float64_t,index_double_object_type,soft_double_less>::index_index sysio::chain::index_double_index

Definition at line 148 of file contract_table_objects.hpp.

◆ index_double_object

typedef secondary_index<float64_t,index_double_object_type,soft_double_less>::index_object sysio::chain::index_double_object

This index supports a deterministic software implementation of double as the secondary key.

The software double implementation is using the Berkeley softfloat library (release 3).

Definition at line 147 of file contract_table_objects.hpp.

◆ index_long_double_index

typedef secondary_index<float128_t,index_long_double_object_type,soft_long_double_less>::index_index sysio::chain::index_long_double_index

Definition at line 156 of file contract_table_objects.hpp.

◆ index_long_double_object

typedef secondary_index<float128_t,index_long_double_object_type,soft_long_double_less>::index_object sysio::chain::index_long_double_object

This index supports a deterministic software implementation of long double as the secondary key.

The software long double implementation is using the Berkeley softfloat library (release 3).

Definition at line 155 of file contract_table_objects.hpp.

◆ int128_t

using sysio::chain::int128_t = __int128

Definition at line 241 of file types.hpp.

◆ key256_t

typedef std::array<uint128_t, 2> sysio::chain::key256_t

Definition at line 125 of file contract_table_objects.hpp.

◆ key_value_index

using sysio::chain::key_value_index

Initial value:

 chainbase::shared_multi_index_container<
      key_value_object,
      indexed_by<
         ordered_unique<tag<by_id>, member<key_value_object, key_value_object::id_type, &key_value_object::id>>,
         ordered_unique<tag<by_scope_primary>,
            composite_key< key_value_object,
               member<key_value_object, table_id, &key_value_object::t_id>,
               member<key_value_object, uint64_t, &key_value_object::primary_key>
            >,
            composite_key_compare< std::less<table_id>, std::less<uint64_t> >
         >
      >
   >

Definition at line 64 of file contract_table_objects.hpp.

◆ legacy_ptr

template<typename T , std::size_t Align = alignof(T)>

using sysio::chain::legacy_ptr = sysio::vm::argument_proxy<T*, Align>

Definition at line 29 of file common.hpp.

◆ legacy_span

template<typename T , std::size_t Align = alignof(T)>

using sysio::chain::legacy_span = sysio::vm::argument_proxy<sysio::vm::span<T>, Align>

Definition at line 32 of file common.hpp.

◆ next_func_t

using sysio::chain::next_func_t = std::function<void(const std::variant<fc::exception_ptr, transaction_trace_ptr>&)>

Definition at line 31 of file unapplied_transaction_queue.hpp.

◆ object_to_table_id_tag_t

template<typename T >

using sysio::chain::object_to_table_id_tag_t = typename object_to_table_id_tag<T>::tag_type

Definition at line 238 of file contract_table_objects.hpp.

◆ packed_transaction_ptr

using sysio::chain::packed_transaction_ptr = std::shared_ptr<const packed_transaction>

Definition at line 214 of file transaction.hpp.

◆ permission_index

using sysio::chain::permission_index

Initial value:

 chainbase::shared_multi_index_container<
      permission_object,
      indexed_by<
         ordered_unique<tag<by_id>, member<permission_object, permission_object::id_type, &permission_object::id>>,
         ordered_unique<tag<by_parent>,
            composite_key<permission_object,
               member<permission_object, permission_object::id_type, &permission_object::parent>,
               member<permission_object, permission_object::id_type, &permission_object::id>
            >
         >,
         ordered_unique<tag<by_owner>,
            composite_key<permission_object,
               member<permission_object, account_name, &permission_object::owner>,
               member<permission_object, permission_name, &permission_object::name>
            >
         >,
         ordered_unique<tag<by_name>,
            composite_key<permission_object,
               member<permission_object, permission_name, &permission_object::name>,
               member<permission_object, permission_object::id_type, &permission_object::id>
            >
         >
      >
   >

Definition at line 86 of file permission_object.hpp.

◆ permission_link_index

using sysio::chain::permission_link_index

Initial value:

 chainbase::shared_multi_index_container<
      permission_link_object,
      indexed_by<
         ordered_unique<tag<by_id>,
 
         >,
         ordered_unique<tag<by_action_name>,
            composite_key<permission_link_object,
               BOOST_MULTI_INDEX_MEMBER(permission_link_object, account_name, account),
               BOOST_MULTI_INDEX_MEMBER(permission_link_object, account_name, code),
 
            >
         >,
         ordered_unique<tag<by_permission_name>,
            composite_key<permission_link_object,
               BOOST_MULTI_INDEX_MEMBER(permission_link_object, account_name, account),
               BOOST_MULTI_INDEX_MEMBER(permission_link_object, permission_name, required_permission),
 
            >
         >
      >
   >

Definition at line 44 of file permission_link_object.hpp.

◆ permission_name

using sysio::chain::permission_name = name

Definition at line 121 of file types.hpp.

◆ permission_usage_index

using sysio::chain::permission_usage_index

Initial value:

 chainbase::shared_multi_index_container<
      permission_usage_object,
      indexed_by<
         ordered_unique<tag<by_id>, member<permission_usage_object, permission_usage_object::id_type, &permission_usage_object::id>>
      >
   >

Definition at line 17 of file permission_object.hpp.

◆ private_key_type

using sysio::chain::private_key_type = fc::crypto::private_key

Definition at line 77 of file types.hpp.

◆ protocol_feature_activation_set_ptr

using sysio::chain::protocol_feature_activation_set_ptr = std::shared_ptr<protocol_feature_activation_set>

Definition at line 34 of file protocol_feature_activation.hpp.

◆ protocol_state_multi_index

using sysio::chain::protocol_state_multi_index

Initial value:

 chainbase::shared_multi_index_container<
      protocol_state_object,
      indexed_by<
         ordered_unique<tag<by_id>,
 
         >
      >
   >

Definition at line 46 of file protocol_state_object.hpp.

◆ public_key_type

using sysio::chain::public_key_type = fc::crypto::public_key

Definition at line 76 of file types.hpp.

◆ recover_keys_future

using sysio::chain::recover_keys_future = std::future<transaction_metadata_ptr>

Definition at line 15 of file transaction_metadata.hpp.

◆ scope_name

using sysio::chain::scope_name = name

Definition at line 119 of file types.hpp.

◆ share_type

using sysio::chain::share_type = int64_t

Definition at line 240 of file types.hpp.

◆ shared_block_signing_authority

using sysio::chain::shared_block_signing_authority = std::variant<shared_block_signing_authority_v0>

Definition at line 63 of file producer_schedule.hpp.

◆ shared_flat_multimap

template<typename K , typename V >

using sysio::chain::shared_flat_multimap = boost::interprocess::flat_multimap< K, V, std::less<K>, allocator< std::pair<K,V> > >

Definition at line 89 of file types.hpp.

◆ shared_incremental_merkle

typedef incremental_merkle_impl<digest_type,shared_vector> sysio::chain::shared_incremental_merkle

Definition at line 247 of file incremental_merkle.hpp.

◆ shared_public_key_data

using sysio::chain::shared_public_key_data = std::variant<fc::ecc::public_key_shim, fc::crypto::r1::public_key_shim, shared_string, fc::em::public_key_shim>

Definition at line 10 of file authority.hpp.

◆ shared_set

template<typename T >

using sysio::chain::shared_set = boost::interprocess::set<T, std::less<T>, allocator<T>>

Definition at line 87 of file types.hpp.

◆ shared_string

using sysio::chain::shared_string = chainbase::shared_string

Definition at line 83 of file types.hpp.

◆ shared_vector

template<typename T >

using sysio::chain::shared_vector = boost::interprocess::vector<T, allocator<T>>

Definition at line 85 of file types.hpp.

◆ signature_type

using sysio::chain::signature_type = fc::crypto::signature

Definition at line 78 of file types.hpp.

◆ signed_block_ptr

using sysio::chain::signed_block_ptr = std::shared_ptr<signed_block>

Definition at line 105 of file block.hpp.

◆ signer_callback_type

using sysio::chain::signer_callback_type = std::function<std::vector<signature_type>(const digest_type&)>

Definition at line 47 of file block_header_state.hpp.

◆ snapshot_reader_ptr

using sysio::chain::snapshot_reader_ptr = std::shared_ptr<snapshot_reader>

Definition at line 294 of file snapshot.hpp.

◆ snapshot_writer_ptr

using sysio::chain::snapshot_writer_ptr = std::shared_ptr<snapshot_writer>

Definition at line 155 of file snapshot.hpp.

◆ span

template<typename T , std::size_t Extent = sysio::vm::dynamic_extent>

using sysio::chain::span = sysio::vm::span<T, Extent>

Definition at line 26 of file common.hpp.

◆ table_id

using sysio::chain::table_id = table_id_object::id_type

Definition at line 44 of file contract_table_objects.hpp.

◆ table_id_multi_index

using sysio::chain::table_id_multi_index

Initial value:

 chainbase::shared_multi_index_container<
      table_id_object,
      indexed_by<
         ordered_unique<tag<by_id>,
            member<table_id_object, table_id_object::id_type, &table_id_object::id>
         >,
         ordered_unique<tag<by_code_scope_table>,
            composite_key< table_id_object,
               member<table_id_object, account_name, &table_id_object::code>,
               member<table_id_object, scope_name,   &table_id_object::scope>,
               member<table_id_object, table_name,   &table_id_object::table>
            >
         >
      >
   >

Definition at line 28 of file contract_table_objects.hpp.

◆ table_name

using sysio::chain::table_name = name

Definition at line 122 of file types.hpp.

◆ transaction_extension

using sysio::chain::transaction_extension = transaction_extension_types::transaction_extension_t

Definition at line 39 of file transaction.hpp.

◆ transaction_extension_types

using sysio::chain::transaction_extension_types

Initial value:

 detail::transaction_extension_types<
      deferred_transaction_generation_context
   >

Definition at line 35 of file transaction.hpp.

◆ transaction_id_type

using sysio::chain::transaction_id_type = checksum_type

Definition at line 236 of file types.hpp.

◆ transaction_index

typedef chainbase::generic_index<transaction_multi_index> sysio::chain::transaction_index

Definition at line 45 of file transaction_object.hpp.

◆ transaction_metadata_ptr

using sysio::chain::transaction_metadata_ptr = std::shared_ptr<transaction_metadata>

Definition at line 14 of file transaction_metadata.hpp.

◆ transaction_multi_index

using sysio::chain::transaction_multi_index

Initial value:

 chainbase::shared_multi_index_container<
      transaction_object,
      indexed_by<
         ordered_unique< tag<by_id>, BOOST_MULTI_INDEX_MEMBER(transaction_object, transaction_object::id_type, id)>,
         ordered_unique< tag<by_trx_id>, BOOST_MULTI_INDEX_MEMBER(transaction_object, transaction_id_type, trx_id)>,
         ordered_unique< tag<by_expiration>,
            composite_key< transaction_object,
               BOOST_MULTI_INDEX_MEMBER( transaction_object, time_point_sec, expiration ),
 
            >
         >
      >
   >

Definition at line 31 of file transaction_object.hpp.

◆ transaction_trace_ptr

using sysio::chain::transaction_trace_ptr = std::shared_ptr<transaction_trace>

Definition at line 20 of file trace.hpp.

◆ trx_meta_cache_lookup

using sysio::chain::trx_meta_cache_lookup = std::function<transaction_metadata_ptr( const transaction_id_type&)>

Definition at line 47 of file controller.hpp.

◆ type_converter

using sysio::chain::type_converter = basic_type_converter<sysio::vm::execution_interface>

Definition at line 116 of file common.hpp.

◆ type_name

using sysio::chain::type_name = string

Definition at line 7 of file abi_def.hpp.

◆ uint128_t

using sysio::chain::uint128_t = unsigned __int128

Definition at line 242 of file types.hpp.

◆ wasm_size_t

using sysio::chain::wasm_size_t = sysio::vm::wasm_size_t

Definition at line 121 of file common.hpp.

◆ weight_type

using sysio::chain::weight_type = uint16_t

Definition at line 238 of file types.hpp.

◆ whitelisted_intrinsics_type

using sysio::chain::whitelisted_intrinsics_type = shared_flat_multimap<uint64_t, shared_string>

Definition at line 7 of file whitelisted_intrinsics.hpp.

Enumeration Type Documentation

◆ builtin_protocol_feature_t

enum class sysio::chain::builtin_protocol_feature_t : uint32_t

strong

Enumerator
preactivate_feature
only_link_to_existing_permission
replace_deferred
no_duplicate_deferred_id
fix_linkauth_restriction
disallow_empty_producer_schedule
restrict_action_to_self
only_bill_first_authorizer
forward_setcode
get_sender
ram_restrictions
webauthn_key
wtmsig_block_signatures
action_return_value
blockchain_parameters
get_code_hash
configurable_wasm_limits
crypto_primitives
get_block_num
em_key
reserved_private_fork_protocol_features

Definition at line 16 of file protocol_feature_manager.hpp.

                                      : uint32_t {
   preactivate_feature = 0,
   only_link_to_existing_permission = 1,
   replace_deferred = 2,
   no_duplicate_deferred_id = 3,
   fix_linkauth_restriction = 4,
   disallow_empty_producer_schedule = 5,
   restrict_action_to_self = 6,
   only_bill_first_authorizer = 7,
   forward_setcode = 8,
   get_sender = 9,
   ram_restrictions = 10,
   webauthn_key = 11,
   wtmsig_block_signatures = 12,
   action_return_value = 13,
   // 14 reserved
   // 15 reserved
   blockchain_parameters = 16, // matches release 2.1 value
   get_code_hash = 17,
   configurable_wasm_limits = 18, // configurable_wasm_limits2,
   crypto_primitives = 19,
   get_block_num = 20,
   em_key = 21,
   reserved_private_fork_protocol_features = 500000,
};

◆ db_read_mode

enum class sysio::chain::db_read_mode

strong

Enumerator
SPECULATIVE
HEAD
READ_ONLY
IRREVERSIBLE

Definition at line 51 of file controller.hpp.

                           {
      SPECULATIVE,
      HEAD,
      READ_ONLY,
      IRREVERSIBLE
   };

◆ object_type

enum sysio::chain::object_type

List all object types from all namespaces here so they can be easily reflected and displayed in debug output. If a 3rd party wants to extend the core code then they will have to change the packed_object::type field from enum_type to uint16 to avoid warnings when converting packed_objects to/from json.

UNUSED_ enums can be taken for new purposes but otherwise the offsets in this enumeration are potentially shared_memory breaking

Enumerator
null_object_type
account_object_type
account_metadata_object_type
permission_object_type
permission_usage_object_type
permission_link_object_type
UNUSED_action_code_object_type
key_value_object_type
index64_object_type
index128_object_type
index256_object_type
index_double_object_type
index_long_double_object_type
global_property_object_type
dynamic_global_property_object_type
block_summary_object_type
transaction_object_type
generated_transaction_object_type
UNUSED_producer_object_type
UNUSED_chain_property_object_type
account_control_history_object_type	Defined by history_plugin.
UNUSED_account_transaction_history_object_type
UNUSED_transaction_history_object_type
public_key_history_object_type	Defined by history_plugin.
UNUSED_balance_object_type
UNUSED_staked_balance_object_type
UNUSED_producer_votes_object_type
UNUSED_producer_schedule_object_type
UNUSED_proxy_vote_object_type
UNUSED_scope_sequence_object_type
table_id_object_type
resource_limits_object_type
resource_usage_object_type
resource_limits_state_object_type
resource_limits_config_object_type
account_history_object_type	Defined by history_plugin.
action_history_object_type	Defined by history_plugin.
reversible_block_object_type
protocol_state_object_type
account_ram_correction_object_type
code_object_type
database_header_object_type
OBJECT_TYPE_COUNT	Sentry value which contains the number of different object types.

Definition at line 135 of file types.hpp.

   {
      null_object_type = 0,
      account_object_type,
      account_metadata_object_type,
      permission_object_type,
      permission_usage_object_type,
      permission_link_object_type,
      UNUSED_action_code_object_type,
      key_value_object_type,
      index64_object_type,
      index128_object_type,
      index256_object_type,
      index_double_object_type,
      index_long_double_object_type,
      global_property_object_type,
      dynamic_global_property_object_type,
      block_summary_object_type,
      transaction_object_type,
      generated_transaction_object_type,
      UNUSED_producer_object_type,
      UNUSED_chain_property_object_type,
      account_control_history_object_type,     
      UNUSED_account_transaction_history_object_type,
      UNUSED_transaction_history_object_type,
      public_key_history_object_type,          
      UNUSED_balance_object_type,
      UNUSED_staked_balance_object_type,
      UNUSED_producer_votes_object_type,
      UNUSED_producer_schedule_object_type,
      UNUSED_proxy_vote_object_type,
      UNUSED_scope_sequence_object_type,
      table_id_object_type,
      resource_limits_object_type,
      resource_usage_object_type,
      resource_limits_state_object_type,
      resource_limits_config_object_type,
      account_history_object_type,              
      action_history_object_type,               
      reversible_block_object_type,
      protocol_state_object_type,
      account_ram_correction_object_type,
      code_object_type,
      database_header_object_type,
      OBJECT_TYPE_COUNT 
   };

◆ protocol_feature_t

enum class sysio::chain::protocol_feature_t : uint32_t

strong

Enumerator
builtin

Definition at line 11 of file protocol_feature_manager.hpp.

                              : uint32_t {
   builtin
};

◆ system_error_code

enum class sysio::chain::system_error_code : uint64_t

strong

Enumerator
generic_system_error
contract_restricted_error_code

Definition at line 133 of file exceptions.hpp.

                                : uint64_t {
      generic_system_error = 10000000000000000000ULL,
      contract_restricted_error_code, //< contract used an error code reserved for system usage
   };

◆ trx_enum_type

enum class sysio::chain::trx_enum_type

strong

Enumerator
unknown
persisted
forked
aborted
incoming_persisted
incoming

Definition at line 22 of file unapplied_transaction_queue.hpp.

                         {
   unknown = 0,
   persisted = 1,
   forked = 2,
   aborted = 3,
   incoming_persisted = 4,
   incoming = 5 // incoming_end() needs to be updated if this changes
};

◆ validation_mode

enum class sysio::chain::validation_mode

strong

Enumerator
FULL
LIGHT

Definition at line 58 of file controller.hpp.

                              {
      FULL,
      LIGHT
   };

Function Documentation

◆ add_intrinsic_to_whitelist()

void sysio::chain::add_intrinsic_to_whitelist	(	whitelisted_intrinsics_type &	whitelisted_intrinsics,
		std::string_view	name )

Definition at line 51 of file whitelisted_intrinsics.cpp.

   {
      uint64_t h = static_cast<uint64_t>( std::hash<std::string_view>{}( name ) );
      auto itr = find_intrinsic( whitelisted_intrinsics, h, name );
      SYS_ASSERT( itr == whitelisted_intrinsics.end(), database_exception,
                  "cannot add intrinsic '${name}' since it already exists in the whitelist",
                  ("name", std::string(name))
      );
 
      whitelisted_intrinsics.emplace( std::piecewise_construct,
                                      std::forward_as_tuple( h ),
                                      std::forward_as_tuple( name.data(), name.size(),
                                                             whitelisted_intrinsics.get_allocator() )
      );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ async_thread_pool()

template<typename F >

auto sysio::chain::async_thread_pool	(	boost::asio::io_context &	thread_pool,
		F &&	f )

Definition at line 41 of file thread_utils.hpp.

                                                                     {
      auto task = std::make_shared<std::packaged_task<decltype( f() )()>>( std::forward<F>( f ) );
      boost::asio::post( thread_pool, [task]() { (*task)(); } );
      return task->get_future();
   }

Here is the caller graph for this function:

◆ block_state_is_valid()

bool sysio::chain::block_state_is_valid ( const block_state & bs )

inline

Definition at line 24 of file fork_database.cpp.

                                                             {
      return bs.is_valid();
   }

◆ builtin_protocol_feature_codename()

const char * sysio::chain::builtin_protocol_feature_codename ( builtin_protocol_feature_t codename )

Definition at line 277 of file protocol_feature_manager.cpp.

                                                                                        {
      auto itr = builtin_protocol_feature_codenames.find( codename );
      SYS_ASSERT( itr != builtin_protocol_feature_codenames.end(), protocol_feature_validation_exception,
                  "Unsupported builtin_protocol_feature_t passed to builtin_protocol_feature_codename: ${codename}",
                  ("codename", static_cast<uint32_t>(codename)) );
 
      return itr->second.codename;
   }

Here is the caller graph for this function:

◆ char_to_symbol()

uint64_t sysio::chain::char_to_symbol ( char c )

inlineconstexpr

Definition at line 16 of file name.hpp.

                                                      {
      if( c >= 'a' && c <= 'z' )
         return (c - 'a') + 6;
      if( c >= '1' && c <= '5' )
         return (c - '1') + 1;
      return 0;
   }

Here is the caller graph for this function:

◆ common_type_defs()

vector< type_def > sysio::chain::common_type_defs ( )

Definition at line 6 of file sysio_contract_abi.cpp.

                                    {
   vector<type_def> types;
 
   types.push_back( type_def{"account_name", "name"} );
   types.push_back( type_def{"permission_name", "name"} );
   types.push_back( type_def{"action_name", "name"} );
   types.push_back( type_def{"table_name", "name"} );
   types.push_back( type_def{"transaction_id_type", "checksum256"} );
   types.push_back( type_def{"block_id_type", "checksum256"} );
   types.push_back( type_def{"weight_type", "uint16"} );
 
   return types;
}

Here is the caller graph for this function:

◆ compute_and_print_timer_accuracy()

void sysio::chain::compute_and_print_timer_accuracy ( platform_timer & t )

Definition at line 21 of file platform_timer_accuracy.cpp.

                                                             {
   static std::mutex m;
   static bool once_is_enough;
 
   std::lock_guard guard(m);
 
   if(once_is_enough)
      return;
 
   bacc::accumulator_set<int, bacc::stats<bacc::tag::mean, bacc::tag::min, bacc::tag::max, bacc::tag::variance>, float> samples;
 
   //keep longest first in list. You're effectively going to take test_intervals[0]*sizeof(test_intervals[0])
   //time to do the the test
   int test_intervals[] = {50000, 10000, 5000, 1000, 500, 100, 50, 10};
 
   for(int& interval : test_intervals) {
      unsigned int loops = test_intervals[0]/interval;
 
      for(unsigned int i = 0; i < loops; ++i) {
         auto start = std::chrono::high_resolution_clock::now();
         timer.start(fc::time_point(fc::time_point::now().time_since_epoch() + fc::microseconds(interval)));
         while(!timer.expired) {}
         auto end = std::chrono::high_resolution_clock::now();
         int timer_slop = std::chrono::duration_cast<std::chrono::microseconds>(end-start).count() - interval;
 
         //since more samples are run for the shorter expirations, weigh the longer expirations accordingly. This
         //helps to make a few results more fair. Two such examples: AWS c4&i5 xen instances being rather stable
         //down to 100us but then struggling with 50us and 10us. MacOS having performance that seems to correlate
         //with expiry length; that is, long expirations have high error, short expirations have low error.
         //That said, for these platforms, a tighter tolerance may possibly be achieved by taking performance
         //metrics in mulitple bins and appliying the slop based on which bin a deadline resides in. Not clear
         //if that's worth the extra complexity at this point.
         samples(timer_slop, bacc::weight = interval/(float)test_intervals[0]);
      }
   }
 
   #define TIMER_STATS_FORMAT "min:${min}us max:${max}us mean:${mean}us stddev:${stddev}us"
   #define TIMER_STATS \
      ("min", bacc::min(samples))("max", bacc::max(samples)) \
      ("mean", (int)bacc::mean(samples))("stddev", (int)sqrt(bacc::variance(samples)))
 
   ilog("Checktime timer accuracy: " TIMER_STATS_FORMAT, TIMER_STATS);
   if(bacc::mean(samples) + sqrt(bacc::variance(samples))*2 > 250)
      wlog("Checktime timer accuracy on this platform and hardware combination is poor; accuracy of subjective transaction deadline enforcement will suffer");
 
   once_is_enough = true;
}

Here is the call graph for this function:

◆ controller_impl::on_activation< builtin_protocol_feature_t::action_return_value >()

template<>

void sysio::chain::controller_impl::on_activation< builtin_protocol_feature_t::action_return_value > ( )

Definition at line 3636 of file controller.cpp.

                                                                                   {
   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "set_action_return_value" );
   } );
}

Here is the call graph for this function:

◆ controller_impl::on_activation< builtin_protocol_feature_t::blockchain_parameters >()

template<>

void sysio::chain::controller_impl::on_activation< builtin_protocol_feature_t::blockchain_parameters > ( )

Definition at line 3651 of file controller.cpp.

                                                                                     {
   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "get_parameters_packed" );
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "set_parameters_packed" );
   } );
}

Here is the call graph for this function:

◆ controller_impl::on_activation< builtin_protocol_feature_t::configurable_wasm_limits >()

template<>

void sysio::chain::controller_impl::on_activation< builtin_protocol_feature_t::configurable_wasm_limits > ( )

Definition at line 3643 of file controller.cpp.

                                                                                        {
   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "set_wasm_parameters_packed" );
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "get_wasm_parameters_packed" );
   } );
}

Here is the call graph for this function:

◆ controller_impl::on_activation< builtin_protocol_feature_t::crypto_primitives >()

template<>

void sysio::chain::controller_impl::on_activation< builtin_protocol_feature_t::crypto_primitives > ( )

Definition at line 3673 of file controller.cpp.

                                                                                 {
   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "alt_bn128_add" );
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "alt_bn128_mul" );
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "alt_bn128_pair" );
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "mod_exp" );
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "blake2_f" );
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "sha3" );
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "k1_recover" );
   } );
}

Here is the call graph for this function:

◆ controller_impl::on_activation< builtin_protocol_feature_t::em_key >()

template<>

void sysio::chain::controller_impl::on_activation< builtin_protocol_feature_t::em_key > ( )

Definition at line 3621 of file controller.cpp.

                                                                      {
   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
      ps.num_supported_key_types = 4;
   } );
}

Here is the call graph for this function:

◆ controller_impl::on_activation< builtin_protocol_feature_t::get_block_num >()

template<>

void sysio::chain::controller_impl::on_activation< builtin_protocol_feature_t::get_block_num > ( )

Definition at line 3666 of file controller.cpp.

                                                                             {
   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "get_block_num" );
   } );
}

Here is the call graph for this function:

◆ controller_impl::on_activation< builtin_protocol_feature_t::get_code_hash >()

template<>

void sysio::chain::controller_impl::on_activation< builtin_protocol_feature_t::get_code_hash > ( )

Definition at line 3659 of file controller.cpp.

                                                                             {
   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "get_code_hash" );
   } );
}

Here is the call graph for this function:

◆ controller_impl::on_activation< builtin_protocol_feature_t::get_sender >()

template<>

void sysio::chain::controller_impl::on_activation< builtin_protocol_feature_t::get_sender > ( )

Definition at line 3586 of file controller.cpp.

                                                                          {
   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "get_sender" );
   } );
}

Here is the call graph for this function:

◆ controller_impl::on_activation< builtin_protocol_feature_t::preactivate_feature >()

template<>

void sysio::chain::controller_impl::on_activation< builtin_protocol_feature_t::preactivate_feature > ( )

Definition at line 3578 of file controller.cpp.

                                                                                   {
   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "preactivate_feature" );
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "is_feature_activated" );
   } );
}

Here is the call graph for this function:

◆ controller_impl::on_activation< builtin_protocol_feature_t::replace_deferred >()

template<>

void sysio::chain::controller_impl::on_activation< builtin_protocol_feature_t::replace_deferred > ( )

Definition at line 3593 of file controller.cpp.

                                                                                {
   const auto& indx = db.get_index<account_ram_correction_index, by_id>();
   for( auto itr = indx.begin(); itr != indx.end(); itr = indx.begin() ) {
      int64_t current_ram_usage = resource_limits.get_account_ram_usage( itr->name );
      int64_t ram_delta = -static_cast<int64_t>(itr->ram_correction);
      if( itr->ram_correction > static_cast<uint64_t>(current_ram_usage) ) {
         ram_delta = -current_ram_usage;
         elog( "account ${name} was to be reduced by ${adjust} bytes of RAM despite only using ${current} bytes of RAM",
               ("name", itr->name)("adjust", itr->ram_correction)("current", current_ram_usage) );
      }
 
      if (auto dm_logger = get_deep_mind_logger()) {
         dm_logger->on_ram_trace(RAM_EVENT_ID("${id}", ("id", itr->id._id)), "deferred_trx", "correction", "deferred_trx_ram_correction");
      }
 
      resource_limits.add_pending_ram_usage( itr->name, ram_delta );
      db.remove( *itr );
   }
}

Here is the call graph for this function:

◆ controller_impl::on_activation< builtin_protocol_feature_t::webauthn_key >()

template<>

void sysio::chain::controller_impl::on_activation< builtin_protocol_feature_t::webauthn_key > ( )

Definition at line 3614 of file controller.cpp.

                                                                            {
   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
      ps.num_supported_key_types = 3;
   } );
}

Here is the call graph for this function:

◆ controller_impl::on_activation< builtin_protocol_feature_t::wtmsig_block_signatures >()

template<>

void sysio::chain::controller_impl::on_activation< builtin_protocol_feature_t::wtmsig_block_signatures > ( )

Definition at line 3629 of file controller.cpp.

                                                                                       {
   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "set_proposed_producers_ex" );
   } );
}

Here is the call graph for this function:

◆ convert_intrinsic_whitelist_to_set()

std::set< std::string > sysio::chain::convert_intrinsic_whitelist_to_set ( const whitelisted_intrinsics_type & whitelisted_intrinsics )

Definition at line 94 of file whitelisted_intrinsics.cpp.

                                                                                                                     {
      std::set<std::string> s;
 
      for( const auto& p : whitelisted_intrinsics ) {
         s.emplace( p.second.data(), p.second.size() );
      }
 
      return s;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ emplace_extension()

auto sysio::chain::emplace_extension	(	extensions_type &	exts,
		uint16_t	eid,
		vector< char > &&	data )

inline

emplace an extension into the extensions type such that it is properly ordered by extension id this assumes exts is already sorted by extension id

Definition at line 264 of file types.hpp.

                                                                                            {
      auto insert_itr = std::upper_bound(exts.begin(), exts.end(), eid, [](uint16_t id, const auto& ext){
         return id < ext.first;
      });
 
      return exts.emplace(insert_itr, eid, std::move(data));
   }

Here is the caller graph for this function:

◆ end_inserter()

template<typename Container >

end_insert_iterator< Container > sysio::chain::end_inserter ( Container & c )

inline

Definition at line 303 of file types.hpp.

                                                                      {
      return end_insert_iterator<Container>( c );
   }

Here is the caller graph for this function:

◆ extensions()

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed sysio::chain::extensions ( invalid block )

◆ FC_DECLARE_DERIVED_EXCEPTION() [1/40]

key Invalid authority Invalid transaction sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	abi_type_exception	,
		chain_type_exception	,
		3010007	,
		"Invalid ABI"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [2/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	abort_called	,
		action_validate_exception	,
		3050008	,
		"Abort Called"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [3/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	account_query_exception	,
		database_exception	,
		3060002	,
		"Account Query Exception"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [4/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	action_data_and_struct_mismatch	,
		action_validate_exception	,
		3050006	,
		"Mismatch between action data and its struct"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [5/40]

key Invalid authority sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	action_type_exception	,
		chain_type_exception	,
		3010005	,
		"Invalid action"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [6/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	action_validate_exception	,
		chain_exception	,
		3050000	,
		"Action validate exception"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [7/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	asset_type_exception	,
		chain_type_exception	,
		3010011	,
		"Invalid asset"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [8/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	block_lock_exception	,
		block_validate_exception	,
		3030004	,
		"Shard locks in block are incorrect or mal-formed"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [9/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	block_too_old_exception	,
		block_validate_exception	,
		3030006	,
		"Block is too old to push"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [10/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	block_tx_output_exception	,
		block_validate_exception	,
		3030002	,
		"Transaction outputs in block do not match transaction outputs from applying block"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [11/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	block_validate_exception	,
		chain_exception	,
		3030000	,
		"Block exception"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [12/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	cfa_inside_generated_tx	,
		transaction_exception	,
		3040010	,
		"Context free action is not allowed inside generated transaction"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [13/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	cfa_irrelevant_auth	,
		transaction_exception	,
		3040004	,
		"Context-free action should have no required authority"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [14/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	contract_query_exception	,
		database_exception	,
		3060004	,
		"Contract Query Exception"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [15/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	database_exception	,
		chain_exception	,
		3060000	,
		"Database exception"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [16/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	fixed_key_type_exception	,
		chain_type_exception	,
		3010013	,
		"Invalid fixed key"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [17/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	fork_database_exception	,
		chain_exception	,
		3020000	,
		"Fork database exception"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [18/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	guard_exception	,
		database_exception	,
		3060100	,
		"Guard Exception"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [19/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	ill_formed_deferred_transaction_generation_context	,
		transaction_exception	,
		3040016	,
		"Transaction includes an ill-formed deferred transaction generation context extension"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [20/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	inline_action_too_big_nonprivileged	,
		action_validate_exception	,
		3050012	,
		"Inline action exceeds maximum size limit for a non-privileged account"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [21/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	invalid_action_args_exception	,
		action_validate_exception	,
		3050002	,
		"Invalid Action Arguments"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [22/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	invalid_block_extension	,
		block_validate_exception	,
		3030012	,
		"Invalid block extension"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [23/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	invalid_block_header_extension	,
		block_validate_exception	,
		3030010	,
		"Invalid block header extension"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [24/40]

chain type exception sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	name_type_exception	,
		chain_type_exception	,
		3010001	,
		"Invalid name"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [25/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version Database usage is at unsafe levels Error in WASM page memory Serialization Error Processing WASM sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	overlapping_memory_error	,
		wasm_exception	,
		3070004	,
		"memcpy with overlapping memory"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [26/40]

key sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	private_key_type_exception	,
		chain_type_exception	,
		3010003	,
		"Invalid private key"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [27/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version Database usage is at unsafe levels Error in WASM page memory Serialization Error Processing WASM binaryen exception sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	resource_exhausted_exception	,
		chain_exception	,
		3080000	,
		"Resource exhausted exception"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [28/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	sysio_assert_code_exception	,
		action_validate_exception	,
		3050004	,
		"sysio_assert_code assertion failure"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [29/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	too_many_tx_at_once	,
		transaction_exception	,
		3040012	,
		"Pushing too many transactions at once"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [30/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	transaction_exception	,
		chain_exception	,
		3040000	,
		"Transaction exception"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [31/40]

key Invalid authority Invalid transaction Invalid block ID sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	transaction_id_type_exception	,
		chain_type_exception	,
		3010009	,
		"Invalid transaction ID"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [32/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	tx_duplicate	,
		transaction_exception	,
		3040008	,
		"Duplicate transaction"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [33/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	tx_exp_too_far_exception	,
		transaction_exception	,
		3040006	,
		"Transaction Expiration Too Far"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [34/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	tx_no_action	,
		transaction_exception	,
		3040002	,
		"Transaction should have at least one normal action"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [35/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	unactivated_key_type	,
		chain_type_exception	,
		3010015	,
		"Key type is not a currently activated type"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [36/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	unauthorized_ram_usage_increase	,
		action_validate_exception	,
		3050010	,
		"Action attempts to increase RAM usage of account without authorization"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [37/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	unknown_transaction_compression	,
		transaction_exception	,
		3040014	,
		"Unknown transaction compression"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [38/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version Database usage is at unsafe levels sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	wasm_exception	,
		chain_exception	,
		3070000	,
		"WASM Exception"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [39/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version Database usage is at unsafe levels Error in WASM page memory sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	wasm_execution_error	,
		wasm_exception	,
		3070002	,
		"Runtime Error Processing WASM"	)

◆ FC_DECLARE_DERIVED_EXCEPTION() [40/40]

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future sysio::chain::FC_DECLARE_DERIVED_EXCEPTION	(	wrong_signing_key	,
		block_validate_exception	,
		3030008	,
		"Block is not signed with expected key"	)

◆ FC_DECLARE_DERIVED_EXCEPTION_WITH_ERROR_CODE()

sysio::chain::FC_DECLARE_DERIVED_EXCEPTION_WITH_ERROR_CODE	(	chain_exception	,
		fc::exception	,
		3000000	,
		"blockchain exception"	)

◆ FC_RETHROW_EXCEPTIONS() [1/2]

sysio::chain::FC_RETHROW_EXCEPTIONS	(	error	,
		"Failed to deserialize variant"	,
		("variant", v)	)

◆ FC_RETHROW_EXCEPTIONS() [2/2]

sysio::chain::FC_RETHROW_EXCEPTIONS	(	error	,
		"Failed to serialize: ${type}"	,
		("type", boost::core::demangle(typeid(o).name()))	)

◆ filter_data_by_marker()

template<typename DataRange , typename MarkerRange , typename Marker >

DataRange sysio::chain::filter_data_by_marker	(	DataRange	data,
		MarkerRange	markers,
		const Marker &	markerValue )

Takes two parallel ranges, a Data range containing data values, and a Marker range containing markers on the corresponding data values. Returns a new Data range containing only the values corresponding to markers which match markerValue

For example:

vector<char> data = {'A', 'B', 'C'};
vector<bool> markers = {true, false, true};
auto markedData = FilterDataByMarker(data, markers, true);
// markedData contains {'A', 'C'}

Definition at line 25 of file parallel_markers.hpp.

                                                                                                {
   auto remove_mismatched_markers = boost::adaptors::filtered([&markerValue](const auto& tuple) {
      return boost::get<0>(tuple) == markerValue;
   });
   auto ToData = boost::adaptors::transformed([](const auto& tuple) {
      return boost::get<1>(tuple);
   });
 
   // Zip the ranges together, filter out data with markers that don't match, and return the data without the markers
   auto range = boost::combine(markers, data) | remove_mismatched_markers | ToData;
   return {range.begin(), range.end()};
}

Here is the caller graph for this function:

◆ find_intrinsic() [1/2]

whitelisted_intrinsics_type::const_iterator sysio::chain::find_intrinsic	(	const whitelisted_intrinsics_type &	whitelisted_intrinsics,
		uint64_t	h,
		std::string_view	name )

Definition at line 30 of file whitelisted_intrinsics.cpp.

   {
      auto itr = whitelisted_intrinsics.lower_bound( h );
      const auto end = whitelisted_intrinsics.end();
 
      if( !find_intrinsic_helper( h, name, itr, end ) )
         return end;
 
      return itr;
   }

Here is the call graph for this function:

◆ find_intrinsic() [2/2]

whitelisted_intrinsics_type::iterator sysio::chain::find_intrinsic	(	whitelisted_intrinsics_type &	whitelisted_intrinsics,
		uint64_t	h,
		std::string_view	name )

Definition at line 18 of file whitelisted_intrinsics.cpp.

   {
      auto itr = whitelisted_intrinsics.lower_bound( h );
      const auto end = whitelisted_intrinsics.end();
 
      if( !find_intrinsic_helper( h, name, itr, end ) )
         return end;
 
      return itr;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_intrinsic_helper()

template<typename Iterator >

bool sysio::chain::find_intrinsic_helper	(	uint64_t	h,
		std::string_view	name,
		Iterator &	itr,
		const Iterator &	end )

Definition at line 7 of file whitelisted_intrinsics.cpp.

                                                                                                     {
      for( ; itr != end && itr->first == h; ++itr ) {
         if( itr->second.compare( 0, itr->second.size(), name.data(), name.size() ) == 0 ) {
            return true;
         }
      }
 
      return false;
   }

Here is the caller graph for this function:

◆ first_preferred()

bool sysio::chain::first_preferred	(	const block_header_state &	lhs,
		const block_header_state &	rhs )

Definition at line 58 of file fork_database.cpp.

                                                                                        {
      return std::tie( lhs.dpos_irreversible_blocknum, lhs.block_num )
               > std::tie( rhs.dpos_irreversible_blocknum, rhs.block_num );
   }

Here is the caller graph for this function:

◆ generate_action_digest()

template<typename Hasher >

auto sysio::chain::generate_action_digest	(	Hasher &&	hash,
		const action &	act,
		const vector< char > &	action_output )

Definition at line 99 of file action.hpp.

                                                                                                    {
      using hash_type = decltype(hash(nullptr, 0));
      hash_type hashes[2];
      const action_base* base = &act;
      const auto action_base_size   = fc::raw::pack_size(*base);
      const auto action_input_size  = fc::raw::pack_size(act.data);
      const auto action_output_size = fc::raw::pack_size(action_output);
      const auto rhs_size           = action_input_size + action_output_size;
      std::vector<char> buff;
      buff.reserve(std::max(action_base_size, rhs_size));
      {
         buff.resize(action_base_size);
         fc::datastream<char*> ds(buff.data(), action_base_size);
         fc::raw::pack(ds, *base);
         hashes[0] = hash(buff.data(), action_base_size);
      }
      {
         buff.resize(rhs_size);
         fc::datastream<char*> ds(buff.data(), rhs_size);
         fc::raw::pack(ds, act.data);
         fc::raw::pack(ds, action_output);
         hashes[1] = hash(buff.data(), rhs_size);
      }
      auto hashes_size = fc::raw::pack_size(hashes[0]) + fc::raw::pack_size(hashes[1]);
      buff.resize(hashes_size); // may cause reallocation but in practice will be unlikely
      fc::datastream<char*> ds(buff.data(), hashes_size);
      fc::raw::pack(ds, hashes[0]);
      fc::raw::pack(ds, hashes[1]);
      return hash(buff.data(), hashes_size);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_canonical_left()

bool sysio::chain::is_canonical_left ( const digest_type & val )

Definition at line 26 of file merkle.cpp.

                                               {
   return (val._hash[0] & 0x0000000000000080ULL) == 0;
}

◆ is_canonical_right()

bool sysio::chain::is_canonical_right ( const digest_type & val )

Definition at line 30 of file merkle.cpp.

                                                {
   return (val._hash[0] & 0x0000000000000080ULL) != 0;
}

◆ is_intrinsic_whitelisted()

bool sysio::chain::is_intrinsic_whitelisted	(	const whitelisted_intrinsics_type &	whitelisted_intrinsics,
		std::string_view	name )

Definition at line 41 of file whitelisted_intrinsics.cpp.

   {
      uint64_t h = static_cast<uint64_t>( std::hash<std::string_view>{}( name ) );
      auto itr = whitelisted_intrinsics.lower_bound( h );
      const auto end = whitelisted_intrinsics.end();
 
      return find_intrinsic_helper( h, name, itr, end );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_onblock()

bool sysio::chain::is_onblock ( const transaction_trace & tt )

inline

Deduce if transaction_trace is the trace of an onblock system transaction

Definition at line 71 of file trace.hpp.

                                                         {
      if (tt.action_traces.empty())
         return false;
      const auto& act = tt.action_traces[0].act;
      if (act.account != sysio::chain::config::system_account_name || act.name != "onblock"_n ||
          act.authorization.size() != 1)
         return false;
      const auto& auth = act.authorization[0];
      return auth.actor == sysio::chain::config::system_account_name &&
             auth.permission == sysio::chain::config::active_name;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_auth_checker()

template<typename PermissionToAuthorityFunc >

auto sysio::chain::make_auth_checker	(	PermissionToAuthorityFunc &&	pta,
		uint16_t	recursion_depth_limit,
		const flat_set< public_key_type > &	provided_keys,
		const flat_set< permission_level > &	provided_permissions = flat_set<permission_level>(),
		fc::microseconds	provided_delay = fc::microseconds(0),
		const std::function< void()> &	_checktime = std::function<void()>() )

Definition at line 259 of file authority_checker.hpp.

   {
      auto noop_checktime = []() {};
      const auto& checktime = ( static_cast<bool>(_checktime) ? _checktime : noop_checktime );
      return authority_checker< PermissionToAuthorityFunc>( std::forward<PermissionToAuthorityFunc>(pta),
                                                            recursion_depth_limit,
                                                            provided_keys,
                                                            provided_permissions,
                                                            provided_delay,
                                                            checktime );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_canonical_left()

digest_type sysio::chain::make_canonical_left ( const digest_type & val )

in order to keep proofs concise, before hashing we set the first bit of the previous hashes to 0 or 1 to indicate the side it is on

this relieves our proofs from having to indicate left vs right contactenation as the node values will imply it

Definition at line 14 of file merkle.cpp.

                                                        {
   digest_type canonical_l = val;
   canonical_l._hash[0] &= 0xFFFFFFFFFFFFFF7FULL;
   return canonical_l;
}

Here is the caller graph for this function:

◆ make_canonical_pair()

auto sysio::chain::make_canonical_pair	(	const digest_type &	l,
		const digest_type &	r )

inline

Definition at line 13 of file merkle.hpp.

                                                                               {
      return make_pair(make_canonical_left(l), make_canonical_right(r));
   };

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_canonical_right()

digest_type sysio::chain::make_canonical_right ( const digest_type & val )

Definition at line 20 of file merkle.cpp.

                                                         {
   digest_type canonical_r = val;
   canonical_r._hash[0] |= 0x0000000000000080ULL;
   return canonical_r;
}

Here is the caller graph for this function:

◆ merkle()

digest_type sysio::chain::merkle ( vector< digest_type > ids )

Calculates the merkle root of a set of digests, if ids is odd it will duplicate the last id.

Definition at line 35 of file merkle.cpp.

                                            {
   if( 0 == ids.size() ) { return digest_type(); }
 
   while( ids.size() > 1 ) {
      if( ids.size() % 2 )
         ids.push_back(ids.back());
 
      for (size_t i = 0; i < ids.size() / 2; i++) {
         ids[i] = digest_type::hash(make_canonical_pair(ids[2 * i], ids[(2 * i) + 1]));
      }
 
      ids.resize(ids.size() / 2);
   }
 
   return ids.front();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ noop_checktime()

void sysio::chain::noop_checktime ( )

Definition at line 466 of file authorization_manager.cpp.

466{}

Here is the caller graph for this function:

◆ operator!=() [1/5]

bool sysio::chain::operator!=	(	const abi_def &	lhs,
		const abi_def &	rhs )

Definition at line 266 of file test_common.hpp.

                                                           {
      return !(lhs == rhs);
   }

◆ operator!=() [2/5]

bool sysio::chain::operator!=	(	const kv_database_config &	lhs,
		const kv_database_config &	rhs )

inline

Definition at line 24 of file kv_config.hpp.

                                                                                        {
      return !(lhs == rhs);
   }

◆ operator!=() [3/5]

bool sysio::chain::operator!=	(	const permission_level &	lhs,
		const permission_level &	rhs )

inline

Definition at line 17 of file action.hpp.

                                                                                     {
      return std::tie(lhs.actor, lhs.permission) != std::tie(rhs.actor, rhs.permission);
   }

◆ operator!=() [4/5]

bool sysio::chain::operator!=	(	const symbol &	lhs,
		const symbol &	rhs )

inline

Definition at line 155 of file symbol.hpp.

      {
         return lhs.value() != rhs.value();
      }

Here is the call graph for this function:

◆ operator!=() [5/5]

bool sysio::chain::operator!=	(	const wasm_config &	lhs,
		const wasm_config &	rhs )

inlineconstexpr

Definition at line 37 of file wasm_config.hpp.

                                                                                 {
   return !(lhs == rhs);
}

◆ operator<() [1/3]

bool sysio::chain::operator<	(	const asset &	a,
		const asset &	b )

Definition at line 59 of file asset.hpp.

   {
      SYS_ASSERT(a.get_symbol() == b.get_symbol(), asset_type_exception, "logical operation between two different asset is not allowed");
      return std::tie(a.amount,a.get_symbol()) < std::tie(b.amount,b.get_symbol());
   }

◆ operator<() [2/3]

bool sysio::chain::operator<	(	const permission_level &	lhs,
		const permission_level &	rhs )

inline

Definition at line 21 of file action.hpp.

                                                                                    {
      return std::tie(lhs.actor, lhs.permission) < std::tie(rhs.actor, rhs.permission);
   }

◆ operator<() [3/3]

bool sysio::chain::operator<	(	const symbol &	lhs,
		const symbol &	rhs )

inline

Definition at line 159 of file symbol.hpp.

      {
         return lhs.value() < rhs.value();
      }

Here is the call graph for this function:

◆ operator<<() [1/4]

template<typename DataStream >

DataStream & sysio::chain::operator<<	(	DataStream &	ds,
		const shared_blob &	b )

Definition at line 84 of file database_utils.hpp.

                                                                    {
      fc::raw::pack(ds, static_cast<const shared_string&>(b));
      return ds;
   }

Here is the call graph for this function:

◆ operator<<() [2/4]

std::ostream & sysio::chain::operator<<	(	std::ostream &	os,
		const abi_def &	abi )

Definition at line 270 of file test_common.hpp.

                                                              {
      os << fc::json::to_string(abi, fc::time_point::maximum());
      return os;
   }

Here is the call graph for this function:

◆ operator<<() [3/4]

std::ostream & sysio::chain::operator<<	(	std::ostream &	osm,
		sysio::chain::db_read_mode	m )

Definition at line 51 of file chain_plugin.cpp.

                                                                  {
   if ( m == sysio::chain::db_read_mode::SPECULATIVE ) {
      osm << "speculative";
   } else if ( m == sysio::chain::db_read_mode::HEAD ) {
      osm << "head";
   } else if ( m == sysio::chain::db_read_mode::READ_ONLY ) { // deprecated
      osm << "read-only";
   } else if ( m == sysio::chain::db_read_mode::IRREVERSIBLE ) {
      osm << "irreversible";
   }
 
   return osm;
}

◆ operator<<() [4/4]

std::ostream & sysio::chain::operator<<	(	std::ostream &	osm,
		sysio::chain::validation_mode	m )

Definition at line 92 of file chain_plugin.cpp.

                                                                     {
   if ( m == sysio::chain::validation_mode::FULL ) {
      osm << "full";
   } else if ( m == sysio::chain::validation_mode::LIGHT ) {
      osm << "light";
   }
 
   return osm;
}

◆ operator<=() [1/2]

bool sysio::chain::operator<=	(	const asset &	a,
		const asset &	b )

Definition at line 64 of file asset.hpp.

64{ return (a == b) || (a < b); }

◆ operator<=() [2/2]

bool sysio::chain::operator<=	(	const permission_level &	lhs,
		const permission_level &	rhs )

inline

Definition at line 25 of file action.hpp.

                                                                                     {
      return std::tie(lhs.actor, lhs.permission) <= std::tie(rhs.actor, rhs.permission);
   }

◆ operator==() [1/6]

bool sysio::chain::operator==	(	const abi_def &	lhs,
		const abi_def &	rhs )

Definition at line 262 of file test_common.hpp.

                                                           {
      return fc::raw::pack(lhs) == fc::raw::pack(rhs);
   }

Here is the call graph for this function:

◆ operator==() [2/6]

bool sysio::chain::operator==	(	const kv_database_config &	lhs,
		const kv_database_config &	rhs )

inline

Definition at line 20 of file kv_config.hpp.

                                                                                        {
      return std::tie(lhs.max_key_size, lhs.max_value_size, lhs.max_iterators)
          == std::tie(rhs.max_key_size, rhs.max_value_size, rhs.max_iterators);
   }

◆ operator==() [3/6]

bool sysio::chain::operator==	(	const permission_level &	lhs,
		const permission_level &	rhs )

inline

Definition at line 13 of file action.hpp.

                                                                                     {
      return std::tie(lhs.actor, lhs.permission) == std::tie(rhs.actor, rhs.permission);
   }

◆ operator==() [4/6]

bool sysio::chain::operator==	(	const producer_authority &	pa,
		const shared_producer_authority &	pb )

inline

Definition at line 310 of file producer_schedule.hpp.

   {
      if(pa.producer_name != pb.producer_name) return false;
      if(pa.authority.index() != pb.authority.index()) return false;
 
      bool authority_matches = std::visit([&pb]( const auto& lhs ){
         return std::visit( [&lhs](const auto& rhs ) {
            if (lhs.threshold != rhs.threshold) return false;
            return std::equal(lhs.keys.cbegin(), lhs.keys.cend(), rhs.keys.cbegin(), rhs.keys.cend());
         }, pb.authority);
      }, pa.authority);
 
      if (!authority_matches) return false;
      return true;
   }

◆ operator==() [5/6]

bool sysio::chain::operator==	(	const symbol &	lhs,
		const symbol &	rhs )

inline

Definition at line 151 of file symbol.hpp.

      {
         return lhs.value() == rhs.value();
      }

Here is the call graph for this function:

◆ operator==() [6/6]

bool sysio::chain::operator==	(	const wasm_config &	lhs,
		const wasm_config &	rhs )

inlineconstexpr

Definition at line 24 of file wasm_config.hpp.

                                                                                 {
   return lhs.max_mutable_global_bytes == rhs.max_mutable_global_bytes &&
     lhs.max_table_elements == rhs.max_table_elements &&
     lhs.max_section_elements == rhs.max_section_elements &&
     lhs.max_linear_memory_init == rhs.max_linear_memory_init &&
     lhs.max_func_local_bytes == rhs.max_func_local_bytes &&
     lhs.max_nested_structures == rhs.max_nested_structures &&
     lhs.max_symbol_bytes == rhs.max_symbol_bytes &&
     lhs.max_module_bytes == rhs.max_module_bytes &&
     lhs.max_code_bytes == rhs.max_code_bytes &&
     lhs.max_pages == rhs.max_pages &&
     lhs.max_call_depth == rhs.max_call_depth;
}

◆ operator>() [1/2]

bool sysio::chain::operator>	(	const permission_level &	lhs,
		const permission_level &	rhs )

inline

Definition at line 29 of file action.hpp.

                                                                                    {
      return std::tie(lhs.actor, lhs.permission) > std::tie(rhs.actor, rhs.permission);
   }

◆ operator>() [2/2]

bool sysio::chain::operator>	(	const symbol &	lhs,
		const symbol &	rhs )

inline

Definition at line 163 of file symbol.hpp.

      {
         return lhs.value() > rhs.value();
      }

Here is the call graph for this function:

◆ operator>=()

bool sysio::chain::operator>=	(	const permission_level &	lhs,
		const permission_level &	rhs )

inline

Definition at line 33 of file action.hpp.

                                                                                     {
      return std::tie(lhs.actor, lhs.permission) >= std::tie(rhs.actor, rhs.permission);
   }

◆ operator>>() [1/2]

template<typename DataStream >

DataStream & sysio::chain::operator>>	(	DataStream &	ds,
		shared_blob &	b )

Definition at line 90 of file database_utils.hpp.

                                                              {
      fc::raw::unpack(ds, static_cast<shared_string &>(b));
      return ds;
   }

Here is the call graph for this function:

◆ operator>>() [2/2]

std::istream & sysio::chain::operator>>	(	std::istream &	in,
		wasm_interface::vm_type &	runtime )

Definition at line 114 of file wasm_interface.cpp.

                                                                       {
   std::string s;
   in >> s;
   if (s == "sys-vm")
      runtime = sysio::chain::wasm_interface::vm_type::eos_vm;
   else if (s == "sys-vm-jit")
      runtime = sysio::chain::wasm_interface::vm_type::eos_vm_jit;
   else if (s == "sys-vm-oc")
      runtime = sysio::chain::wasm_interface::vm_type::eos_vm_oc;
   else
      in.setstate(std::ios_base::failbit);
   return in;
}

◆ overloaded()

template<class... Ts>

sysio::chain::overloaded ( Ts... ) -> overloaded< Ts... >

◆ pack_function()

template<typename T >

auto sysio::chain::pack_function ( )

Definition at line 34 of file abi_serializer.cpp.

                        {
      return []( const fc::variant& var, fc::datastream<char*>& ds, bool is_array, bool is_optional, const abi_serializer::yield_function_t& yield ){
         if( is_array )
            fc::raw::pack( ds, var.as<vector<T>>() );
         else if ( is_optional )
            fc::raw::pack( ds, var.as<std::optional<T>>() );
         else
            fc::raw::pack( ds,  var.as<T>());
      };
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pack_unpack()

template<typename T >

auto sysio::chain::pack_unpack ( )

Definition at line 46 of file abi_serializer.cpp.

                      {
      return std::make_pair<abi_serializer::unpack_function, abi_serializer::pack_function>(
         []( fc::datastream<const char*>& stream, bool is_array, bool is_optional, const abi_serializer::yield_function_t& yield) {
            if( is_array )
               return variant_from_stream<vector<T>>(stream);
            else if ( is_optional )
               return variant_from_stream<std::optional<T>>(stream);
            return variant_from_stream<T>(stream);
         },
         pack_function<T>()
      );
   }

Here is the call graph for this function:

◆ pack_unpack_deadline()

template<typename T >

auto sysio::chain::pack_unpack_deadline ( )

Definition at line 60 of file abi_serializer.cpp.

                               {
      return std::make_pair<abi_serializer::unpack_function, abi_serializer::pack_function>(
         []( fc::datastream<const char*>& stream, bool is_array, bool is_optional, const abi_serializer::yield_function_t& yield) {
            if( is_array )
               return variant_from_stream<vector<T>>(stream);
            else if ( is_optional )
               return variant_from_stream<std::optional<T>>(stream);
            return variant_from_stream<T>(stream, yield);
         },
         pack_function<T>()
      );
   }

Here is the call graph for this function:

◆ remove_intrinsic_from_whitelist()

void sysio::chain::remove_intrinsic_from_whitelist	(	whitelisted_intrinsics_type &	whitelisted_intrinsics,
		std::string_view	name )

Definition at line 67 of file whitelisted_intrinsics.cpp.

   {
      uint64_t h = static_cast<uint64_t>( std::hash<std::string_view>{}( name ) );
      auto itr = find_intrinsic( whitelisted_intrinsics, h, name );
      SYS_ASSERT( itr != whitelisted_intrinsics.end(), database_exception,
                  "cannot remove intrinsic '${name}' since it does not exist in the whitelist",
                  ("name", std::string(name))
      );
 
      whitelisted_intrinsics.erase( itr );
   }

Here is the call graph for this function:

◆ reset_intrinsic_whitelist()

void sysio::chain::reset_intrinsic_whitelist	(	whitelisted_intrinsics_type &	whitelisted_intrinsics,
		const std::set< std::string > &	s )

Definition at line 79 of file whitelisted_intrinsics.cpp.

   {
      whitelisted_intrinsics.clear();
 
      for( const auto& name : s ) {
         uint64_t h = static_cast<uint64_t>( std::hash<std::string_view>{}( name ) );
         whitelisted_intrinsics.emplace( std::piecewise_construct,
                                         std::forward_as_tuple( h ),
                                         std::forward_as_tuple( name.data(), name.size(),
                                                                whitelisted_intrinsics.get_allocator() )
         );
      }
   }

Here is the caller graph for this function:

◆ string_to_name()

name sysio::chain::string_to_name ( std::string_view str )

inlineconstexpr

Definition at line 84 of file name.hpp.

   {
      return name( string_to_uint64_t( str ) );
   }

Here is the call graph for this function:

◆ string_to_uint64_t()

uint64_t sysio::chain::string_to_uint64_t ( std::string_view str )

inlineconstexpr

Definition at line 24 of file name.hpp.

                                                                      {
      uint64_t n = 0;
      size_t i = 0;
      for ( ; i < str.size() && i < 12; ++i) {
         // NOTE: char_to_symbol() returns char type, and without this explicit
         // expansion to uint64 type, the compilation fails at the point of usage
         // of string_to_name(), where the usage requires constant (compile time) expression.
         n |= (char_to_symbol(str[i]) & 0x1f) << (64 - 5 * (i + 1));
      }
 
      // The for-loop encoded up to 60 high bits into uint64 'name' variable,
      // if (strlen(str) > 12) then encode str[12] into the low (remaining)
      // 4 bits of 'name'
      if (i < str.size() && i == 12)
         n |= char_to_symbol(str[12]) & 0x0F;
      return n;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sysio_contract_abi()

abi_def sysio::chain::sysio_contract_abi ( const abi_def & sysio_system_abi )

Definition at line 20 of file sysio_contract_abi.cpp.

{
   abi_def eos_abi(sysio_system_abi);
 
   if( eos_abi.version.size() == 0 ) {
      eos_abi.version = "sysio::abi/1.0";
   }
 
   fc::move_append(eos_abi.types, common_type_defs());
 
   // transaction
   eos_abi.structs.emplace_back( struct_def {
      "permission_level", "", {
         {"actor", "account_name"},
         {"permission", "permission_name"}
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "action", "", {
         {"account", "account_name"},
         {"name", "action_name"},
         {"authorization", "permission_level[]"},
         {"data", "bytes"}
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "extension", "", {
         {"type", "uint16"},
         {"data", "bytes"}
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "transaction_header", "", {
         {"expiration", "time_point_sec"},
         {"ref_block_num", "uint16"},
         {"ref_block_prefix", "uint32"},
         {"max_net_usage_words", "varuint32"},
         {"max_cpu_usage_ms", "uint8"},
         {"delay_sec", "varuint32"}
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "transaction", "transaction_header", {
         {"context_free_actions", "action[]"},
         {"actions", "action[]"},
         {"transaction_extensions", "extension[]"}
      }
   });
 
   // block_header
 
   eos_abi.structs.emplace_back( struct_def {
      "producer_key", "", {
         {"producer_name", "account_name"},
         {"block_signing_key", "public_key"}
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "producer_schedule", "", {
         {"version", "uint32"},
         {"producers", "producer_key[]"}
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "block_header", "", {
         {"timestamp", "uint32"},
         {"producer", "account_name"},
         {"confirmed", "uint16"},
         {"previous", "block_id_type"},
         {"transaction_mroot", "checksum256"},
         {"action_mroot", "checksum256"},
         {"schedule_version", "uint32"},
         {"new_producers", "producer_schedule?"},
         {"header_extensions", "extension[]"}
      }
   });
 
   // authority
   eos_abi.structs.emplace_back( struct_def {
      "key_weight", "", {
         {"key", "public_key"},
         {"weight", "weight_type"}
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "permission_level_weight", "", {
         {"permission", "permission_level"},
         {"weight", "weight_type"}
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "wait_weight", "", {
         {"wait_sec", "uint32"},
         {"weight", "weight_type"}
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "authority", "", {
         {"threshold", "uint32"},
         {"keys", "key_weight[]"},
         {"accounts", "permission_level_weight[]"},
         {"waits", "wait_weight[]"}
      }
   });
 
   // TODO add any ricardian_clauses
   //
   // ACTION PAYLOADS
 
   eos_abi.structs.emplace_back( struct_def {
      "newaccount", "", {
         {"creator", "account_name"},
         {"name", "account_name"},
         {"owner", "authority"},
         {"active", "authority"},
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "setcode", "", {
         {"account", "account_name"},
         {"vmtype", "uint8"},
         {"vmversion", "uint8"},
         {"code", "bytes"}
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "setabi", "", {
         {"account", "account_name"},
         {"abi",     "bytes"}
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "updateauth", "", {
         {"account", "account_name"},
         {"permission", "permission_name"},
         {"parent", "permission_name"},
         {"auth", "authority"}
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "deleteauth", "", {
         {"account", "account_name"},
         {"permission", "permission_name"},
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "linkauth", "", {
         {"account", "account_name"},
         {"code", "account_name"},
         {"type", "action_name"},
         {"requirement", "permission_name"},
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "unlinkauth", "", {
         {"account", "account_name"},
         {"code", "account_name"},
         {"type", "action_name"},
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
      "canceldelay", "", {
         {"canceling_auth", "permission_level"},
         {"trx_id", "transaction_id_type"},
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
         "onerror", "", {
            {"sender_id", "uint128"},
            {"sent_trx",  "bytes"}
      }
   });
 
   eos_abi.structs.emplace_back( struct_def {
         "onblock", "", {
            {"header", "block_header"}
      }
   });
 
   // TODO add ricardian contracts
   eos_abi.actions.push_back( action_def{name("newaccount"), "newaccount",""} );
   eos_abi.actions.push_back( action_def{name("setcode"), "setcode",""} );
   eos_abi.actions.push_back( action_def{name("setabi"), "setabi",""} );
   eos_abi.actions.push_back( action_def{name("updateauth"), "updateauth",""} );
   eos_abi.actions.push_back( action_def{name("deleteauth"), "deleteauth",""} );
   eos_abi.actions.push_back( action_def{name("linkauth"), "linkauth",""} );
   eos_abi.actions.push_back( action_def{name("unlinkauth"), "unlinkauth",""} );
   eos_abi.actions.push_back( action_def{name("canceldelay"), "canceldelay",""} );
   eos_abi.actions.push_back( action_def{name("onerror"), "onerror",""} );
   eos_abi.actions.push_back( action_def{name("onblock"), "onblock",""} );
 
   return eos_abi;
}

Here is the call graph for this function:

◆ transaction_id_to_sender_id()

uint128_t sysio::chain::transaction_id_to_sender_id ( const transaction_id_type & tid )

Definition at line 28 of file sysio_contract.cpp.

                                                                        {
   fc::uint128 _id(tid._hash[3], tid._hash[2]);
   return (unsigned __int128)_id;
}

Here is the caller graph for this function:

◆ validate() [1/3]

void sysio::chain::validate	(	boost::any &	v,
		const std::vector< std::string > &	values,
		sysio::chain::db_read_mode *	,
		int	)

Definition at line 65 of file chain_plugin.cpp.

{
  using namespace boost::program_options;
 
  // Make sure no previous assignment to 'v' was made.
  validators::check_first_occurrence(v);
 
  // Extract the first string from 'values'. If there is more than
  // one string, it's an error, and exception will be thrown.
  std::string const& s = validators::get_single_string(values);
 
  if ( s == "speculative" ) {
     v = boost::any(sysio::chain::db_read_mode::SPECULATIVE);
  } else if ( s == "head" ) {
     v = boost::any(sysio::chain::db_read_mode::HEAD);
  } else if ( s == "read-only" ) {
     v = boost::any(sysio::chain::db_read_mode::READ_ONLY);
  } else if ( s == "irreversible" ) {
     v = boost::any(sysio::chain::db_read_mode::IRREVERSIBLE);
  } else {
     throw validation_error(validation_error::invalid_option_value);
  }
}

◆ validate() [2/3]

void sysio::chain::validate	(	boost::any &	v,
		const std::vector< std::string > &	values,
		sysio::chain::validation_mode *	,
		int	)

Definition at line 102 of file chain_plugin.cpp.

{
  using namespace boost::program_options;
 
  // Make sure no previous assignment to 'v' was made.
  validators::check_first_occurrence(v);
 
  // Extract the first string from 'values'. If there is more than
  // one string, it's an error, and exception will be thrown.
  std::string const& s = validators::get_single_string(values);
 
  if ( s == "full" ) {
     v = boost::any(sysio::chain::validation_mode::FULL);
  } else if ( s == "light" ) {
     v = boost::any(sysio::chain::validation_mode::LIGHT);
  } else {
     throw validation_error(validation_error::invalid_option_value);
  }
}

◆ validate() [3/3]

template<typename Authority >

bool sysio::chain::validate ( const Authority & auth )

inline

Makes sure all keys are unique and sorted and all account permissions are unique and sorted and that authority can be satisfied

Definition at line 262 of file authority.hpp.

                                              {
   decltype(auth.threshold) total_weight = 0;
 
   static_assert( std::is_same<decltype(auth.threshold), uint32_t>::value &&
                  std::is_same<weight_type, uint16_t>::value &&
                  std::is_same<typename decltype(auth.keys)::value_type, key_weight>::value &&
                  std::is_same<typename decltype(auth.accounts)::value_type, permission_level_weight>::value &&
                  std::is_same<typename decltype(auth.waits)::value_type, wait_weight>::value,
                  "unexpected type for threshold and/or weight in authority" );
 
   if( ( auth.keys.size() + auth.accounts.size() + auth.waits.size() ) > (1 << 16) )
      return false; // overflow protection (assumes weight_type is uint16_t and threshold is of type uint32_t)
 
   if( auth.threshold == 0 )
      return false;
 
   {
      const key_weight* prev = nullptr;
      for( const auto& k : auth.keys ) {
         if( prev && !(prev->key < k.key) ) return false; // TODO: require keys to be sorted in ascending order rather than descending (requires modifying many tests)
         total_weight += k.weight;
         prev = &k;
      }
   }
   {
      const permission_level_weight* prev = nullptr;
      for( const auto& a : auth.accounts ) {
         if( prev && ( prev->permission >= a.permission ) ) return false; // TODO: require permission_levels to be sorted in ascending order rather than descending (requires modifying many tests)
         total_weight += a.weight;
         prev = &a;
      }
   }
   {
      const wait_weight* prev = nullptr;
      if( auth.waits.size() > 0 && auth.waits.front().wait_sec == 0 )
         return false;
      for( const auto& w : auth.waits ) {
         if( prev && ( prev->wait_sec >= w.wait_sec ) ) return false;
         total_weight += w.weight;
         prev = &w;
      }
   }
 
   return total_weight >= auth.threshold;
}

Here is the caller graph for this function:

◆ validate_authority_precondition()

void sysio::chain::validate_authority_precondition	(	const apply_context &	context,
		const authority &	auth )

Definition at line 33 of file sysio_contract.cpp.

                                                                                            {
   for(const auto& a : auth.accounts) {
      auto* acct = context.db.find<account_object, by_name>(a.permission.actor);
      SYS_ASSERT( acct != nullptr, action_validate_exception,
                  "account '${account}' does not exist",
                  ("account", a.permission.actor)
                );
 
      if( a.permission.permission == config::owner_name || a.permission.permission == config::active_name )
         continue; // account was already checked to exist, so its owner and active permissions should exist
 
      if( a.permission.permission == config::sysio_code_name ) // virtual sysio.code permission does not really exist but is allowed
         continue;
 
      try {
         context.control.get_authorization_manager().get_permission({a.permission.actor, a.permission.permission});
      } catch( const permission_query_exception& ) {
         SYS_THROW( action_validate_exception,
                    "permission '${perm}' does not exist",
                    ("perm", a.permission)
                  );
      }
   }
 
   if( context.trx_context.enforce_whiteblacklist && context.control.is_producing_block() ) {
      for( const auto& p : auth.keys ) {
         context.control.check_key_list( p.key );
      }
   }
}

Here is the caller graph for this function:

◆ variant_from_stream() [1/2]

template<typename T >

fc::variant sysio::chain::variant_from_stream ( fc::datastream< const char * > & stream )

inline

Definition at line 18 of file abi_serializer.cpp.

                                                                           {
      T temp;
      fc::raw::unpack( stream, temp );
      return fc::variant(temp);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ variant_from_stream() [2/2]

template<typename T >

fc::variant sysio::chain::variant_from_stream	(	fc::datastream< const char * > &	stream,
		const abi_serializer::yield_function_t &	yield )

inline

Definition at line 25 of file abi_serializer.cpp.

                                                                                                                        {
      fc::yield_function_t y = [&yield](){ yield(0); }; // create yield function matching fc::variant requirements, 0 for recursive depth
      T temp;
      fc::raw::unpack( stream, temp );
      y();
      return fc::variant( temp, y );
   }

Here is the call graph for this function:

◆ wast_to_wasm()

std::vector< uint8_t > sysio::chain::wast_to_wasm ( const std::string & wast )

Definition at line 15 of file wast_to_wasm.cpp.

   { 
      std::stringstream ss;
      
      try {
      IR::Module module;
      std::vector<WAST::Error> parse_errors;
      WAST::parseModule(wast.c_str(),wast.size(),module,parse_errors);
      if(parse_errors.size())
      {
         // Print any parse errors;
         ss << "Error parsing WebAssembly text file:" << std::endl;
         for(auto& error : parse_errors)
         {
            ss << ":" << error.locus.describe() << ": " << error.message.c_str() << std::endl;
            ss << error.locus.sourceLine << std::endl;
            ss << std::setw(error.locus.column(8)) << "^" << std::endl;
         }
         SYS_ASSERT( false, wasm_exception, "error parsing wast: ${msg}", ("msg",ss.str()) );
      }
 
      for(auto sectionIt = module.userSections.begin();sectionIt != module.userSections.end();++sectionIt)
      {
         if(sectionIt->name == "name") { module.userSections.erase(sectionIt); break; }
      }
 
      try
      {
         // Serialize the WebAssembly module.
         Serialization::ArrayOutputStream stream;
         WASM::serialize(stream,module);
         return stream.getBytes();
      }
      catch(const Serialization::FatalSerializationException& exception)
      {
         ss << "Error serializing WebAssembly binary file:" << std::endl;
         ss << exception.message << std::endl;
         SYS_ASSERT( false, wasm_exception, "error converting to wasm: ${msg}", ("msg",ss.get()) );
      } catch(const IR::ValidationException& e) {
         ss << "Error validating WebAssembly binary file:" << std::endl;
         ss << e.message << std::endl;
         SYS_ASSERT( false, wasm_exception, "error converting to wasm: ${msg}", ("msg",ss.get()) );
      }
 
   } FC_CAPTURE_AND_RETHROW( (wast) ) }  

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ action_validate_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value sysio::chain::action_validate_exception

Definition at line 284 of file exceptions.hpp.

◆ block_validate_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension sysio::chain::block_validate_exception

Definition at line 212 of file exceptions.hpp.

◆ builtin_protocol_feature_codenames

const std::unordered_map< builtin_protocol_feature_t, builtin_protocol_feature_spec, enum_hash< builtin_protocol_feature_t > > sysio::chain::builtin_protocol_feature_codenames

Definition at line 14 of file protocol_feature_manager.cpp.

◆ chain_exception

sysio::chain::chain_exception

Definition at line 165 of file exceptions.hpp.

◆ chain_type_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol sysio::chain::chain_type_exception

Definition at line 170 of file exceptions.hpp.

◆ database_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception sysio::chain::database_exception

Definition at line 314 of file exceptions.hpp.

◆ fork_database_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type sysio::chain::fork_database_exception

Definition at line 205 of file exceptions.hpp.

◆ genesis_intrinsics

const std::vector< const char * > sysio::chain::genesis_intrinsics

Definition at line 5 of file genesis_intrinsics.cpp.

                                                  {
   "__ashrti3",
   "__lshlti3",
   "__lshrti3",
   "__ashlti3",
   "__divti3",
   "__udivti3",
   "__modti3",
   "__umodti3",
   "__multi3",
   "__addtf3",
   "__subtf3",
   "__multf3",
   "__divtf3",
   "__eqtf2",
   "__netf2",
   "__getf2",
   "__gttf2",
   "__lttf2",
   "__letf2",
   "__cmptf2",
   "__unordtf2",
   "__negtf2",
   "__floatsitf",
   "__floatunsitf",
   "__floatditf",
   "__floatunditf",
   "__floattidf",
   "__floatuntidf",
   "__floatsidf",
   "__extendsftf2",
   "__extenddftf2",
   "__fixtfti",
   "__fixtfdi",
   "__fixtfsi",
   "__fixunstfti",
   "__fixunstfdi",
   "__fixunstfsi",
   "__fixsfti",
   "__fixdfti",
   "__fixunssfti",
   "__fixunsdfti",
   "__trunctfdf2",
   "__trunctfsf2",
   "is_feature_active",
   "activate_feature",
   "get_resource_limits",
   "set_resource_limits",
   "set_proposed_producers",
   "get_blockchain_parameters_packed",
   "set_blockchain_parameters_packed",
   "is_privileged",
   "set_privileged",
   "get_active_producers",
   "db_idx64_store",
   "db_idx64_remove",
   "db_idx64_update",
   "db_idx64_find_primary",
   "db_idx64_find_secondary",
   "db_idx64_lowerbound",
   "db_idx64_upperbound",
   "db_idx64_end",
   "db_idx64_next",
   "db_idx64_previous",
   "db_idx128_store",
   "db_idx128_remove",
   "db_idx128_update",
   "db_idx128_find_primary",
   "db_idx128_find_secondary",
   "db_idx128_lowerbound",
   "db_idx128_upperbound",
   "db_idx128_end",
   "db_idx128_next",
   "db_idx128_previous",
   "db_idx256_store",
   "db_idx256_remove",
   "db_idx256_update",
   "db_idx256_find_primary",
   "db_idx256_find_secondary",
   "db_idx256_lowerbound",
   "db_idx256_upperbound",
   "db_idx256_end",
   "db_idx256_next",
   "db_idx256_previous",
   "db_idx_double_store",
   "db_idx_double_remove",
   "db_idx_double_update",
   "db_idx_double_find_primary",
   "db_idx_double_find_secondary",
   "db_idx_double_lowerbound",
   "db_idx_double_upperbound",
   "db_idx_double_end",
   "db_idx_double_next",
   "db_idx_double_previous",
   "db_idx_long_double_store",
   "db_idx_long_double_remove",
   "db_idx_long_double_update",
   "db_idx_long_double_find_primary",
   "db_idx_long_double_find_secondary",
   "db_idx_long_double_lowerbound",
   "db_idx_long_double_upperbound",
   "db_idx_long_double_end",
   "db_idx_long_double_next",
   "db_idx_long_double_previous",
   "db_store_i64",
   "db_update_i64",
   "db_remove_i64",
   "db_get_i64",
   "db_next_i64",
   "db_previous_i64",
   "db_find_i64",
   "db_lowerbound_i64",
   "db_upperbound_i64",
   "db_end_i64",
   "assert_recover_key",
   "recover_key",
   "assert_sha256",
   "assert_sha1",
   "assert_sha512",
   "assert_ripemd160",
   "sha1",
   "sha256",
   "sha512",
   "ripemd160",
   "check_transaction_authorization",
   "check_permission_authorization",
   "get_permission_last_used",
   "get_account_creation_time",
   "current_time",
   "publication_time",
   "abort",
   "sysio_assert",
   "sysio_assert_message",
   "sysio_assert_code",
   "sysio_exit",
   "read_action_data",
   "action_data_size",
   "current_receiver",
   "require_recipient",
   "require_auth",
   "require_auth2",
   "has_auth",
   "is_account",
   "prints",
   "prints_l",
   "printi",
   "printui",
   "printi128",
   "printui128",
   "printsf",
   "printdf",
   "printqf",
   "printn",
   "printhex",
   "read_transaction",
   "transaction_size",
   "expiration",
   "tapos_block_prefix",
   "tapos_block_num",
   "get_action",
   "send_inline",
   "send_context_free_inline",
   "send_deferred",
   "cancel_deferred",
   "get_context_free_data",
   "memcpy",
   "memmove",
   "memcmp",
   "memset"
};

◆ guard_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version sysio::chain::guard_exception

Definition at line 328 of file exceptions.hpp.

◆ resource_exhausted_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version Database usage is at unsafe levels Error in WASM page memory Serialization Error Processing WASM binaryen exception sysio::chain::resource_exhausted_exception

Definition at line 348 of file exceptions.hpp.

◆ sysio_abi_bin

unsigned char sysio::chain::sysio_abi_bin

Definition at line 9 of file sysio_contract_abi_bin.cpp.

                                    {
   0x0e, 0x65, 0x6f, 0x73, 0x69, 0x6f, 0x3a, 0x3a, 0x61, 0x62, 0x69, 0x2f,
   0x31, 0x2e, 0x30, 0x07, 0x0c, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74,
   0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x0f, 0x70,
   0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61,
   0x6d, 0x65, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x0b, 0x61, 0x63, 0x74, 0x69,
   0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x04, 0x6e, 0x61, 0x6d, 0x65,
   0x0a, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x04,
   0x6e, 0x61, 0x6d, 0x65, 0x13, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63,
   0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65,
   0x0b, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x32, 0x35, 0x36,
   0x0d, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x5f, 0x74, 0x79,
   0x70, 0x65, 0x0b, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x32,
   0x35, 0x36, 0x0b, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x74, 0x79,
   0x70, 0x65, 0x06, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x36, 0x16, 0x10, 0x70,
   0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6c, 0x65,
   0x76, 0x65, 0x6c, 0x00, 0x02, 0x05, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x0c,
   0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
   0x0a, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x0f,
   0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6e,
   0x61, 0x6d, 0x65, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x04,
   0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x0c, 0x61, 0x63, 0x63,
   0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x04, 0x6e, 0x61,
   0x6d, 0x65, 0x0b, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61,
   0x6d, 0x65, 0x0d, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61,
   0x74, 0x69, 0x6f, 0x6e, 0x12, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73,
   0x69, 0x6f, 0x6e, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x5b, 0x5d, 0x04,
   0x64, 0x61, 0x74, 0x61, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x09, 0x65,
   0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x02, 0x04, 0x74,
   0x79, 0x70, 0x65, 0x06, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x36, 0x04, 0x64,
   0x61, 0x74, 0x61, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12, 0x74, 0x72,
   0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x65,
   0x61, 0x64, 0x65, 0x72, 0x00, 0x06, 0x0a, 0x65, 0x78, 0x70, 0x69, 0x72,
   0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x70,
   0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x73, 0x65, 0x63, 0x0d, 0x72, 0x65, 0x66,
   0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e, 0x75, 0x6d, 0x06, 0x75,
   0x69, 0x6e, 0x74, 0x31, 0x36, 0x10, 0x72, 0x65, 0x66, 0x5f, 0x62, 0x6c,
   0x6f, 0x63, 0x6b, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x06, 0x75,
   0x69, 0x6e, 0x74, 0x33, 0x32, 0x13, 0x6d, 0x61, 0x78, 0x5f, 0x6e, 0x65,
   0x74, 0x5f, 0x75, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x77, 0x6f, 0x72, 0x64,
   0x73, 0x09, 0x76, 0x61, 0x72, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x10,
   0x6d, 0x61, 0x78, 0x5f, 0x63, 0x70, 0x75, 0x5f, 0x75, 0x73, 0x61, 0x67,
   0x65, 0x5f, 0x6d, 0x73, 0x05, 0x75, 0x69, 0x6e, 0x74, 0x38, 0x09, 0x64,
   0x65, 0x6c, 0x61, 0x79, 0x5f, 0x73, 0x65, 0x63, 0x09, 0x76, 0x61, 0x72,
   0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x0b, 0x74, 0x72, 0x61, 0x6e, 0x73,
   0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x74, 0x72, 0x61, 0x6e, 0x73,
   0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65,
   0x72, 0x03, 0x14, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x5f, 0x66,
   0x72, 0x65, 0x65, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x08,
   0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5b, 0x5d, 0x07, 0x61, 0x63, 0x74,
   0x69, 0x6f, 0x6e, 0x73, 0x08, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5b,
   0x5d, 0x16, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f,
   0x6e, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73,
   0x0b, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5b, 0x5d,
   0x0c, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72, 0x5f, 0x6b, 0x65,
   0x79, 0x00, 0x02, 0x0d, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72,
   0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x0c, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e,
   0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x11, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
   0x5f, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x6b, 0x65, 0x79,
   0x0a, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x11,
   0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72, 0x5f, 0x73, 0x63, 0x68,
   0x65, 0x64, 0x75, 0x6c, 0x65, 0x00, 0x02, 0x07, 0x76, 0x65, 0x72, 0x73,
   0x69, 0x6f, 0x6e, 0x06, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x09, 0x70,
   0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72, 0x73, 0x0e, 0x70, 0x72, 0x6f,
   0x64, 0x75, 0x63, 0x65, 0x72, 0x5f, 0x6b, 0x65, 0x79, 0x5b, 0x5d, 0x0c,
   0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72,
   0x00, 0x09, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
   0x06, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x08, 0x70, 0x72, 0x6f, 0x64,
   0x75, 0x63, 0x65, 0x72, 0x0c, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74,
   0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x09, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72,
   0x6d, 0x65, 0x64, 0x06, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x36, 0x08, 0x70,
   0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x0d, 0x62, 0x6c, 0x6f, 0x63,
   0x6b, 0x5f, 0x69, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x11, 0x74, 0x72,
   0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x72,
   0x6f, 0x6f, 0x74, 0x0b, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d,
   0x32, 0x35, 0x36, 0x0c, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d,
   0x72, 0x6f, 0x6f, 0x74, 0x0b, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75,
   0x6d, 0x32, 0x35, 0x36, 0x10, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c,
   0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x06, 0x75, 0x69,
   0x6e, 0x74, 0x33, 0x32, 0x0d, 0x6e, 0x65, 0x77, 0x5f, 0x70, 0x72, 0x6f,
   0x64, 0x75, 0x63, 0x65, 0x72, 0x73, 0x12, 0x70, 0x72, 0x6f, 0x64, 0x75,
   0x63, 0x65, 0x72, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65,
   0x3f, 0x11, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x65, 0x78, 0x74,
   0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x0b, 0x65, 0x78, 0x74, 0x65,
   0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5b, 0x5d, 0x0a, 0x6b, 0x65, 0x79, 0x5f,
   0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x00, 0x02, 0x03, 0x6b, 0x65, 0x79,
   0x0a, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x06,
   0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x0b, 0x77, 0x65, 0x69, 0x67, 0x68,
   0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x17, 0x70, 0x65, 0x72, 0x6d, 0x69,
   0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x5f,
   0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x00, 0x02, 0x0a, 0x70, 0x65, 0x72,
   0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x10, 0x70, 0x65, 0x72, 0x6d,
   0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x6c,
   0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x0b, 0x77, 0x65, 0x69, 0x67,
   0x68, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x0b, 0x77, 0x61, 0x69, 0x74,
   0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x00, 0x02, 0x08, 0x77, 0x61,
   0x69, 0x74, 0x5f, 0x73, 0x65, 0x63, 0x06, 0x75, 0x69, 0x6e, 0x74, 0x33,
   0x32, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x0b, 0x77, 0x65, 0x69,
   0x67, 0x68, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x09, 0x61, 0x75, 0x74,
   0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x00, 0x04, 0x09, 0x74, 0x68, 0x72,
   0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x06, 0x75, 0x69, 0x6e, 0x74, 0x33,
   0x32, 0x04, 0x6b, 0x65, 0x79, 0x73, 0x0c, 0x6b, 0x65, 0x79, 0x5f, 0x77,
   0x65, 0x69, 0x67, 0x68, 0x74, 0x5b, 0x5d, 0x08, 0x61, 0x63, 0x63, 0x6f,
   0x75, 0x6e, 0x74, 0x73, 0x19, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73,
   0x69, 0x6f, 0x6e, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x5f, 0x77, 0x65,
   0x69, 0x67, 0x68, 0x74, 0x5b, 0x5d, 0x05, 0x77, 0x61, 0x69, 0x74, 0x73,
   0x0d, 0x77, 0x61, 0x69, 0x74, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74,
   0x5b, 0x5d, 0x0a, 0x6e, 0x65, 0x77, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e,
   0x74, 0x00, 0x04, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x0c,
   0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
   0x04, 0x6e, 0x61, 0x6d, 0x65, 0x0c, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e,
   0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x05, 0x6f, 0x77, 0x6e, 0x65, 0x72,
   0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x06, 0x61,
   0x63, 0x74, 0x69, 0x76, 0x65, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72,
   0x69, 0x74, 0x79, 0x07, 0x73, 0x65, 0x74, 0x63, 0x6f, 0x64, 0x65, 0x00,
   0x04, 0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x0c, 0x61, 0x63,
   0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x06, 0x76,
   0x6d, 0x74, 0x79, 0x70, 0x65, 0x05, 0x75, 0x69, 0x6e, 0x74, 0x38, 0x09,
   0x76, 0x6d, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x05, 0x75, 0x69,
   0x6e, 0x74, 0x38, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x05, 0x62, 0x79, 0x74,
   0x65, 0x73, 0x06, 0x73, 0x65, 0x74, 0x61, 0x62, 0x69, 0x00, 0x02, 0x07,
   0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x0c, 0x61, 0x63, 0x63, 0x6f,
   0x75, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x03, 0x61, 0x62, 0x69,
   0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74,
   0x65, 0x61, 0x75, 0x74, 0x68, 0x00, 0x04, 0x07, 0x61, 0x63, 0x63, 0x6f,
   0x75, 0x6e, 0x74, 0x0c, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f,
   0x6e, 0x61, 0x6d, 0x65, 0x0a, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73,
   0x69, 0x6f, 0x6e, 0x0f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69,
   0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x06, 0x70, 0x61, 0x72, 0x65,
   0x6e, 0x74, 0x0f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f,
   0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x04, 0x61, 0x75, 0x74, 0x68, 0x09,
   0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x0a, 0x64, 0x65,
   0x6c, 0x65, 0x74, 0x65, 0x61, 0x75, 0x74, 0x68, 0x00, 0x02, 0x07, 0x61,
   0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x0c, 0x61, 0x63, 0x63, 0x6f, 0x75,
   0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x0a, 0x70, 0x65, 0x72, 0x6d,
   0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x0f, 0x70, 0x65, 0x72, 0x6d, 0x69,
   0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x08, 0x6c,
   0x69, 0x6e, 0x6b, 0x61, 0x75, 0x74, 0x68, 0x00, 0x04, 0x07, 0x61, 0x63,
   0x63, 0x6f, 0x75, 0x6e, 0x74, 0x0c, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e,
   0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x0c,
   0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
   0x04, 0x74, 0x79, 0x70, 0x65, 0x0b, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e,
   0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x0b, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72,
   0x65, 0x6d, 0x65, 0x6e, 0x74, 0x0f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73,
   0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x0a, 0x75, 0x6e,
   0x6c, 0x69, 0x6e, 0x6b, 0x61, 0x75, 0x74, 0x68, 0x00, 0x03, 0x07, 0x61,
   0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x0c, 0x61, 0x63, 0x63, 0x6f, 0x75,
   0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x04, 0x63, 0x6f, 0x64, 0x65,
   0x0c, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d,
   0x65, 0x04, 0x74, 0x79, 0x70, 0x65, 0x0b, 0x61, 0x63, 0x74, 0x69, 0x6f,
   0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x0b, 0x63, 0x61, 0x6e, 0x63, 0x65,
   0x6c, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x00, 0x02, 0x0e, 0x63, 0x61, 0x6e,
   0x63, 0x65, 0x6c, 0x69, 0x6e, 0x67, 0x5f, 0x61, 0x75, 0x74, 0x68, 0x10,
   0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6c,
   0x65, 0x76, 0x65, 0x6c, 0x06, 0x74, 0x72, 0x78, 0x5f, 0x69, 0x64, 0x13,
   0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
   0x69, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x07, 0x6f, 0x6e, 0x65, 0x72,
   0x72, 0x6f, 0x72, 0x00, 0x02, 0x09, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72,
   0x5f, 0x69, 0x64, 0x07, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x08,
   0x73, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x72, 0x78, 0x05, 0x62, 0x79, 0x74,
   0x65, 0x73, 0x07, 0x6f, 0x6e, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x00, 0x01,
   0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x0c, 0x62, 0x6c, 0x6f, 0x63,
   0x6b, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x0a, 0x00, 0x40, 0x9e,
   0x9a, 0x22, 0x64, 0xb8, 0x9a, 0x0a, 0x6e, 0x65, 0x77, 0x61, 0x63, 0x63,
   0x6f, 0x75, 0x6e, 0x74, 0x00, 0x00, 0x00, 0x00, 0x40, 0x25, 0x8a, 0xb2,
   0xc2, 0x07, 0x73, 0x65, 0x74, 0x63, 0x6f, 0x64, 0x65, 0x00, 0x00, 0x00,
   0x00, 0x00, 0xb8, 0x63, 0xb2, 0xc2, 0x06, 0x73, 0x65, 0x74, 0x61, 0x62,
   0x69, 0x00, 0x00, 0x40, 0xcb, 0xda, 0xa8, 0x6c, 0x52, 0xd5, 0x0a, 0x75,
   0x70, 0x64, 0x61, 0x74, 0x65, 0x61, 0x75, 0x74, 0x68, 0x00, 0x00, 0x40,
   0xcb, 0xda, 0xa8, 0xac, 0xa2, 0x4a, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x74,
   0x65, 0x61, 0x75, 0x74, 0x68, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x6b, 0x03,
   0xa7, 0x8b, 0x08, 0x6c, 0x69, 0x6e, 0x6b, 0x61, 0x75, 0x74, 0x68, 0x00,
   0x00, 0x40, 0xcb, 0xda, 0xc0, 0xe9, 0xe2, 0xd4, 0x0a, 0x75, 0x6e, 0x6c,
   0x69, 0x6e, 0x6b, 0x61, 0x75, 0x74, 0x68, 0x00, 0x00, 0xbc, 0x89, 0x2a,
   0x45, 0x85, 0xa6, 0x41, 0x0b, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x64,
   0x65, 0x6c, 0x61, 0x79, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xd2, 0x7b, 0xd5,
   0xa4, 0x07, 0x6f, 0x6e, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x22, 0x1a, 0xcf, 0xa4, 0x07, 0x6f, 0x6e, 0x62, 0x6c, 0x6f,
   0x63, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

◆ transaction_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed sysio::chain::transaction_exception

Definition at line 243 of file exceptions.hpp.

◆ wasm_exception

key Invalid authority Invalid transaction Invalid block ID Invalid packed transaction Invalid chain ID Invalid symbol Signature type is not a currently activated type Block can not be found Unlinkable block Block does not guarantee concurrent execution without conflicts Block exhausted allowed resources Block is from the future Block is not signed by expected producer Block includes an ill formed protocol feature activation extension Block includes an ill formed additional block signature extension Error decompressing transaction Transaction should have at least one required authority Expired Transaction Invalid Reference Block Duplicate deferred transaction The transaction can not be found Transaction is too big Invalid transaction extension Transaction includes disallowed Transaction exceeded transient resource limit Account name already exists sysio_assert_message assertion failure Action can not be found Attempt to use unaccessible API Inline Action exceeds maximum size limit sysio_assert_code assertion failure uses restricted error code value action return value size too big Permission Query Exception Contract Table Query Exception Database is an unknown or unsupported version Database usage is at unsafe levels Error in WASM page memory Serialization Error Processing WASM sysio::chain::wasm_exception

Definition at line 333 of file exceptions.hpp.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ account_id_type

◆ account_index

◆ account_metadata_index

◆ account_name

◆ account_ram_correction_index

◆ action_name

◆ apply_handler

◆ authorization_index_set

◆ block_extension

◆ block_extension_types

◆ block_header_extension

◆ block_header_extension_types

◆ block_header_state_ptr

◆ block_id_type

◆ block_num_type

◆ block_signing_authority

◆ block_stage_type

◆ block_state_ptr

◆ block_summary_multi_index

◆ block_timestamp_type

◆ branch_type

◆ bytes

◆ chain_config

◆ checksum160_type

◆ checksum256_type

◆ checksum512_type

◆ checksum_type

◆ code_index

◆ config_range

◆ contract_database_index_set

◆ controller_index_set

◆ database_header_multi_index

◆ digest_type

◆ dynamic_global_property_multi_index

◆ eos_vm_backend_t

◆ eos_vm_host_functions_t

◆ eos_vm_null_backend_t

◆ extensions_type

◆ field_name

◆ fork_multi_index_type

◆ forked_branch_callback

◆ generated_transaction_multi_index

◆ global_property_multi_index

◆ incremental_merkle

◆ index128_index

◆ index128_object

◆ index256_index

◆ index256_object

◆ index64_index

◆ index64_object

◆ index_double_index

◆ index_double_object

◆ index_long_double_index

◆ index_long_double_object

◆ int128_t

◆ key256_t

◆ key_value_index

◆ legacy_ptr

◆ legacy_span

◆ next_func_t

◆ object_to_table_id_tag_t

◆ packed_transaction_ptr

◆ permission_index

◆ permission_link_index

◆ permission_name

◆ permission_usage_index

◆ private_key_type

◆ protocol_feature_activation_set_ptr

◆ protocol_state_multi_index

◆ public_key_type

◆ recover_keys_future

◆ scope_name

◆ share_type