Struct VMHooksDispatcher 

pub struct VMHooksDispatcher<C: VMHooksContext> { /* private fields */ }

Dispatches messages coming via VMHooks to the underlying implementation (the VMHooksHandler).

Implementations

impl<C: VMHooksContext> VMHooksDispatcher<C>

pub fn new(vh_context: C) -> Self

Trait Implementations

impl<C: Debug + VMHooksContext> Debug for VMHooksDispatcher<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C: VMHooksContext> VMHooks for VMHooksDispatcher<C>

fn get_gas_left(&mut self) -> Result<i64, VMHooksEarlyExit>

fn get_sc_address( &mut self, result_offset: MemPtr, ) -> Result<(), VMHooksEarlyExit>

fn get_owner_address( &mut self, result_offset: MemPtr, ) -> Result<(), VMHooksEarlyExit>

fn get_shard_of_address( &mut self, address_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn is_smart_contract( &mut self, address_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn signal_error( &mut self, message_offset: MemPtr, message_length: MemLength, ) -> Result<(), VMHooksEarlyExit>

fn get_external_balance( &mut self, address_offset: MemPtr, result_offset: MemPtr, ) -> Result<(), VMHooksEarlyExit>

fn get_block_hash( &mut self, nonce: i64, result_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn get_esdt_balance( &mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, result_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn get_esdt_nft_name_length( &mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, ) -> Result<i32, VMHooksEarlyExit>

fn get_esdt_nft_attribute_length( &mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, ) -> Result<i32, VMHooksEarlyExit>

fn get_esdt_nft_uri_length( &mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, ) -> Result<i32, VMHooksEarlyExit>

fn get_esdt_token_data( &mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, value_handle: i32, properties_offset: MemPtr, hash_offset: MemPtr, name_offset: MemPtr, attributes_offset: MemPtr, creator_offset: MemPtr, royalties_handle: i32, uris_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn get_esdt_local_roles( &mut self, token_id_handle: i32, ) -> Result<i64, VMHooksEarlyExit>

fn validate_token_identifier( &mut self, token_id_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn transfer_value( &mut self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength, ) -> Result<i32, VMHooksEarlyExit>

fn transfer_value_execute( &mut self, dest_offset: MemPtr, value_offset: MemPtr, gas_limit: i64, function_offset: MemPtr, function_length: MemLength, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn transfer_esdt_execute( &mut self, dest_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, value_offset: MemPtr, gas_limit: i64, function_offset: MemPtr, function_length: MemLength, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn transfer_esdt_nft_execute( &mut self, dest_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, value_offset: MemPtr, nonce: i64, gas_limit: i64, function_offset: MemPtr, function_length: MemLength, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn multi_transfer_esdt_nft_execute( &mut self, dest_offset: MemPtr, num_token_transfers: i32, token_transfers_args_length_offset: MemPtr, token_transfer_data_offset: MemPtr, gas_limit: i64, function_offset: MemPtr, function_length: MemLength, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn create_async_call( &mut self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, data_length: MemLength, success_offset: MemPtr, success_length: MemLength, error_offset: MemPtr, error_length: MemLength, gas: i64, extra_gas_for_callback: i64, ) -> Result<i32, VMHooksEarlyExit>

fn set_async_context_callback( &mut self, callback: MemPtr, callback_length: MemLength, data: MemPtr, data_length: MemLength, gas: i64, ) -> Result<i32, VMHooksEarlyExit>

fn upgrade_contract( &mut self, dest_offset: MemPtr, gas_limit: i64, value_offset: MemPtr, code_offset: MemPtr, code_metadata_offset: MemPtr, length: MemLength, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr, ) -> Result<(), VMHooksEarlyExit>

fn upgrade_from_source_contract( &mut self, dest_offset: MemPtr, gas_limit: i64, value_offset: MemPtr, source_contract_address_offset: MemPtr, code_metadata_offset: MemPtr, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr, ) -> Result<(), VMHooksEarlyExit>

fn delete_contract( &mut self, dest_offset: MemPtr, gas_limit: i64, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr, ) -> Result<(), VMHooksEarlyExit>

fn async_call( &mut self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength, ) -> Result<(), VMHooksEarlyExit>

fn get_argument_length(&mut self, id: i32) -> Result<i32, VMHooksEarlyExit>

fn get_argument( &mut self, id: i32, arg_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn get_function( &mut self, function_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn get_num_arguments(&mut self) -> Result<i32, VMHooksEarlyExit>

fn storage_store( &mut self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr, data_length: MemLength, ) -> Result<i32, VMHooksEarlyExit>

fn storage_load_length( &mut self, key_offset: MemPtr, key_length: MemLength, ) -> Result<i32, VMHooksEarlyExit>

fn storage_load_from_address( &mut self, address_offset: MemPtr, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn storage_load( &mut self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn set_storage_lock( &mut self, key_offset: MemPtr, key_length: MemLength, lock_timestamp: i64, ) -> Result<i32, VMHooksEarlyExit>

fn get_storage_lock( &mut self, key_offset: MemPtr, key_length: MemLength, ) -> Result<i64, VMHooksEarlyExit>

fn is_storage_locked( &mut self, key_offset: MemPtr, key_length: MemLength, ) -> Result<i32, VMHooksEarlyExit>

fn clear_storage_lock( &mut self, key_offset: MemPtr, key_length: MemLength, ) -> Result<i32, VMHooksEarlyExit>

fn get_caller(&mut self, result_offset: MemPtr) -> Result<(), VMHooksEarlyExit>

fn check_no_payment(&mut self) -> Result<(), VMHooksEarlyExit>

fn get_call_value( &mut self, result_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn get_esdt_value( &mut self, result_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn get_esdt_value_by_index( &mut self, result_offset: MemPtr, index: i32, ) -> Result<i32, VMHooksEarlyExit>

fn get_esdt_token_name( &mut self, result_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn get_esdt_token_name_by_index( &mut self, result_offset: MemPtr, index: i32, ) -> Result<i32, VMHooksEarlyExit>

fn get_esdt_token_nonce(&mut self) -> Result<i64, VMHooksEarlyExit>

fn get_esdt_token_nonce_by_index( &mut self, index: i32, ) -> Result<i64, VMHooksEarlyExit>

fn get_current_esdt_nft_nonce( &mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, ) -> Result<i64, VMHooksEarlyExit>

fn get_esdt_token_type(&mut self) -> Result<i32, VMHooksEarlyExit>

fn get_esdt_token_type_by_index( &mut self, index: i32, ) -> Result<i32, VMHooksEarlyExit>

fn get_num_esdt_transfers(&mut self) -> Result<i32, VMHooksEarlyExit>

fn get_call_value_token_name( &mut self, call_value_offset: MemPtr, token_name_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn get_call_value_token_name_by_index( &mut self, call_value_offset: MemPtr, token_name_offset: MemPtr, index: i32, ) -> Result<i32, VMHooksEarlyExit>

fn write_log( &mut self, data_pointer: MemPtr, data_length: MemLength, topic_ptr: MemPtr, num_topics: i32, ) -> Result<(), VMHooksEarlyExit>

fn write_event_log( &mut self, num_topics: i32, topic_lengths_offset: MemPtr, topic_offset: MemPtr, data_offset: MemPtr, data_length: MemLength, ) -> Result<(), VMHooksEarlyExit>

fn get_block_timestamp(&mut self) -> Result<i64, VMHooksEarlyExit>

fn get_block_timestamp_ms(&mut self) -> Result<i64, VMHooksEarlyExit>

fn get_block_nonce(&mut self) -> Result<i64, VMHooksEarlyExit>

fn get_block_round(&mut self) -> Result<i64, VMHooksEarlyExit>

fn get_block_epoch(&mut self) -> Result<i64, VMHooksEarlyExit>

fn get_block_random_seed( &mut self, pointer: MemPtr, ) -> Result<(), VMHooksEarlyExit>

fn get_state_root_hash( &mut self, pointer: MemPtr, ) -> Result<(), VMHooksEarlyExit>

fn get_prev_block_timestamp(&mut self) -> Result<i64, VMHooksEarlyExit>

fn get_prev_block_timestamp_ms(&mut self) -> Result<i64, VMHooksEarlyExit>

fn get_prev_block_nonce(&mut self) -> Result<i64, VMHooksEarlyExit>

fn get_prev_block_round(&mut self) -> Result<i64, VMHooksEarlyExit>

fn get_prev_block_epoch(&mut self) -> Result<i64, VMHooksEarlyExit>

fn get_prev_block_random_seed( &mut self, pointer: MemPtr, ) -> Result<(), VMHooksEarlyExit>

fn finish( &mut self, pointer: MemPtr, length: MemLength, ) -> Result<(), VMHooksEarlyExit>

fn execute_on_same_context( &mut self, gas_limit: i64, address_offset: MemPtr, value_offset: MemPtr, function_offset: MemPtr, function_length: MemLength, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn execute_on_dest_context( &mut self, gas_limit: i64, address_offset: MemPtr, value_offset: MemPtr, function_offset: MemPtr, function_length: MemLength, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn execute_read_only( &mut self, gas_limit: i64, address_offset: MemPtr, function_offset: MemPtr, function_length: MemLength, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn create_contract( &mut self, gas_limit: i64, value_offset: MemPtr, code_offset: MemPtr, code_metadata_offset: MemPtr, length: MemLength, result_offset: MemPtr, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn deploy_from_source_contract( &mut self, gas_limit: i64, value_offset: MemPtr, source_contract_address_offset: MemPtr, code_metadata_offset: MemPtr, result_address_offset: MemPtr, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn get_num_return_data(&mut self) -> Result<i32, VMHooksEarlyExit>

fn get_return_data_size( &mut self, result_id: i32, ) -> Result<i32, VMHooksEarlyExit>

fn get_return_data( &mut self, result_id: i32, data_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn clean_return_data(&mut self) -> Result<(), VMHooksEarlyExit>

fn delete_from_return_data( &mut self, result_id: i32, ) -> Result<(), VMHooksEarlyExit>

fn get_original_tx_hash( &mut self, data_offset: MemPtr, ) -> Result<(), VMHooksEarlyExit>

fn get_current_tx_hash( &mut self, data_offset: MemPtr, ) -> Result<(), VMHooksEarlyExit>

fn get_prev_tx_hash( &mut self, data_offset: MemPtr, ) -> Result<(), VMHooksEarlyExit>

fn managed_sc_address( &mut self, destination_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_owner_address( &mut self, destination_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_caller( &mut self, destination_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_signal_error( &mut self, err_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_write_log( &mut self, topics_handle: i32, data_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_get_original_tx_hash( &mut self, result_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_get_state_root_hash( &mut self, result_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_get_block_random_seed( &mut self, result_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_get_prev_block_random_seed( &mut self, result_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn get_block_round_time_ms(&mut self) -> Result<i64, VMHooksEarlyExit>

fn epoch_start_block_timestamp_ms(&mut self) -> Result<i64, VMHooksEarlyExit>

fn epoch_start_block_nonce(&mut self) -> Result<i64, VMHooksEarlyExit>

fn epoch_start_block_round(&mut self) -> Result<i64, VMHooksEarlyExit>

fn managed_get_return_data( &mut self, result_id: i32, result_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_get_all_transfers_call_value( &mut self, all_transfers_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_get_multi_esdt_call_value( &mut self, multi_call_value_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_get_esdt_balance( &mut self, address_handle: i32, token_id_handle: i32, nonce: i64, value_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_get_esdt_token_data( &mut self, address_handle: i32, token_id_handle: i32, nonce: i64, value_handle: i32, properties_handle: i32, hash_handle: i32, name_handle: i32, attributes_handle: i32, creator_handle: i32, royalties_handle: i32, uris_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_get_esdt_token_type( &mut self, address_handle: i32, token_id_handle: i32, nonce: i64, type_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_get_back_transfers( &mut self, esdt_transfer_value_handle: i32, call_value_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_async_call( &mut self, dest_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_create_async_call( &mut self, dest_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, success_offset: MemPtr, success_length: MemLength, error_offset: MemPtr, error_length: MemLength, gas: i64, extra_gas_for_callback: i64, callback_closure_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_get_callback_closure( &mut self, callback_closure_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_upgrade_from_source_contract( &mut self, dest_handle: i32, gas: i64, value_handle: i32, address_handle: i32, code_metadata_handle: i32, arguments_handle: i32, _result_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_upgrade_contract( &mut self, dest_handle: i32, gas: i64, value_handle: i32, code_handle: i32, code_metadata_handle: i32, arguments_handle: i32, _result_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_delete_contract( &mut self, dest_handle: i32, gas_limit: i64, arguments_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_deploy_from_source_contract( &mut self, gas: i64, value_handle: i32, address_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_address_handle: i32, result_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_create_contract( &mut self, gas: i64, value_handle: i32, code_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_address_handle: i32, result_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_execute_read_only( &mut self, gas: i64, address_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_execute_on_same_context( &mut self, gas: i64, address_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_execute_on_dest_context( &mut self, gas: i64, address_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_execute_on_dest_context_with_error_return( &mut self, gas: i64, address_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_multi_transfer_esdt_nft_execute( &mut self, dst_handle: i32, token_transfers_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_multi_transfer_esdt_nft_execute_with_return( &mut self, dst_handle: i32, token_transfers_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_transfer_value_execute( &mut self, dst_handle: i32, value_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_is_esdt_frozen( &mut self, address_handle: i32, token_id_handle: i32, nonce: i64, ) -> Result<i32, VMHooksEarlyExit>

fn managed_is_esdt_limited_transfer( &mut self, _token_id_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_is_esdt_paused( &mut self, _token_id_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_buffer_to_hex( &mut self, source_handle: i32, dest_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_get_code_metadata( &mut self, address_handle: i32, response_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_get_code_hash( &mut self, address_handle: i32, code_hash_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_is_builtin_function( &mut self, function_name_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn big_float_new_from_parts( &mut self, integral_part: i32, fractional_part: i32, exponent: i32, ) -> Result<i32, VMHooksEarlyExit>

fn big_float_new_from_frac( &mut self, numerator: i64, denominator: i64, ) -> Result<i32, VMHooksEarlyExit>

fn big_float_new_from_sci( &mut self, significand: i64, exponent: i64, ) -> Result<i32, VMHooksEarlyExit>

fn big_float_add( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_float_sub( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_float_mul( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_float_div( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_float_neg( &mut self, destination_handle: i32, op_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_float_clone( &mut self, destination_handle: i32, op_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_float_cmp( &mut self, op1_handle: i32, op2_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn big_float_abs( &mut self, destination_handle: i32, op_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_float_sign(&mut self, op_handle: i32) -> Result<i32, VMHooksEarlyExit>

fn big_float_sqrt( &mut self, destination_handle: i32, op_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_float_pow( &mut self, destination_handle: i32, op_handle: i32, exponent: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_float_floor( &mut self, dest_big_int_handle: i32, op_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_float_ceil( &mut self, dest_big_int_handle: i32, op_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_float_truncate( &mut self, dest_big_int_handle: i32, op_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_float_set_int64( &mut self, destination_handle: i32, value: i64, ) -> Result<(), VMHooksEarlyExit>

fn big_float_is_int(&mut self, op_handle: i32) -> Result<i32, VMHooksEarlyExit>

fn big_float_set_big_int( &mut self, destination_handle: i32, big_int_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_float_get_const_pi( &mut self, destination_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_float_get_const_e( &mut self, destination_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_get_unsigned_argument( &mut self, id: i32, destination_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_get_signed_argument( &mut self, id: i32, destination_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_storage_store_unsigned( &mut self, key_offset: MemPtr, key_length: MemLength, source_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn big_int_storage_load_unsigned( &mut self, key_offset: MemPtr, key_length: MemLength, destination_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn big_int_get_call_value( &mut self, destination_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_get_esdt_call_value( &mut self, destination: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_get_esdt_call_value_by_index( &mut self, destination_handle: i32, index: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_get_external_balance( &mut self, address_offset: MemPtr, result: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_get_esdt_external_balance( &mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, result_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_new(&mut self, small_value: i64) -> Result<i32, VMHooksEarlyExit>

fn big_int_unsigned_byte_length( &mut self, reference_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn big_int_signed_byte_length( &mut self, reference_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn big_int_get_unsigned_bytes( &mut self, reference_handle: i32, byte_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn big_int_get_signed_bytes( &mut self, reference_handle: i32, byte_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn big_int_set_unsigned_bytes( &mut self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength, ) -> Result<(), VMHooksEarlyExit>

fn big_int_set_signed_bytes( &mut self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength, ) -> Result<(), VMHooksEarlyExit>

fn big_int_is_int64( &mut self, destination_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn big_int_get_int64( &mut self, destination_handle: i32, ) -> Result<i64, VMHooksEarlyExit>

fn big_int_set_int64( &mut self, destination_handle: i32, value: i64, ) -> Result<(), VMHooksEarlyExit>

fn big_int_add( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_sub( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_mul( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_tdiv( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_tmod( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_ediv( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_emod( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_sqrt( &mut self, destination_handle: i32, op_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_pow( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_log2(&mut self, op_handle: i32) -> Result<i32, VMHooksEarlyExit>

fn big_int_abs( &mut self, destination_handle: i32, op_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_neg( &mut self, destination_handle: i32, op_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_sign(&mut self, op_handle: i32) -> Result<i32, VMHooksEarlyExit>

fn big_int_cmp( &mut self, op1_handle: i32, op2_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn big_int_not( &mut self, destination_handle: i32, op_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_and( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_or( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_xor( &mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_shr( &mut self, destination_handle: i32, op_handle: i32, bits: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_shl( &mut self, destination_handle: i32, op_handle: i32, bits: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_finish_unsigned( &mut self, reference_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_finish_signed( &mut self, reference_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn big_int_to_string( &mut self, big_int_handle: i32, destination_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn mbuffer_new(&mut self) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_new_from_bytes( &mut self, data_offset: MemPtr, data_length: MemLength, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_get_length( &mut self, m_buffer_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_get_bytes( &mut self, m_buffer_handle: i32, result_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_get_byte_slice( &mut self, source_handle: i32, starting_position: i32, slice_length: i32, result_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_copy_byte_slice( &mut self, source_handle: i32, starting_position: i32, slice_length: i32, destination_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_eq( &mut self, m_buffer_handle1: i32, m_buffer_handle2: i32, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_set_bytes( &mut self, m_buffer_handle: i32, data_offset: MemPtr, data_length: MemLength, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_set_byte_slice( &mut self, m_buffer_handle: i32, starting_position: i32, data_length: MemLength, data_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_append( &mut self, accumulator_handle: i32, data_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_append_bytes( &mut self, accumulator_handle: i32, data_offset: MemPtr, data_length: MemLength, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_to_big_int_unsigned( &mut self, m_buffer_handle: i32, big_int_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_to_big_int_signed( &mut self, m_buffer_handle: i32, big_int_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_from_big_int_unsigned( &mut self, m_buffer_handle: i32, big_int_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_from_big_int_signed( &mut self, m_buffer_handle: i32, big_int_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_to_small_int_unsigned( &mut self, m_buffer_handle: i32, ) -> Result<i64, VMHooksEarlyExit>

fn mbuffer_to_small_int_signed( &mut self, m_buffer_handle: i32, ) -> Result<i64, VMHooksEarlyExit>

fn mbuffer_from_small_int_unsigned( &mut self, m_buffer_handle: i32, value: i64, ) -> Result<(), VMHooksEarlyExit>

fn mbuffer_from_small_int_signed( &mut self, m_buffer_handle: i32, value: i64, ) -> Result<(), VMHooksEarlyExit>

fn mbuffer_to_big_float( &mut self, m_buffer_handle: i32, big_float_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_from_big_float( &mut self, m_buffer_handle: i32, big_float_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_storage_store( &mut self, key_handle: i32, source_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_storage_load( &mut self, key_handle: i32, destination_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_storage_load_from_address( &mut self, address_handle: i32, key_handle: i32, destination_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn mbuffer_get_argument( &mut self, id: i32, destination_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_finish( &mut self, source_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn mbuffer_set_random( &mut self, destination_handle: i32, length: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_map_new(&mut self) -> Result<i32, VMHooksEarlyExit>

fn managed_map_put( &mut self, map_handle: i32, key_handle: i32, value_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_map_get( &mut self, map_handle: i32, key_handle: i32, out_value_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_map_remove( &mut self, map_handle: i32, key_handle: i32, out_value_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_map_contains( &mut self, map_handle: i32, key_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn small_int_get_unsigned_argument( &mut self, id: i32, ) -> Result<i64, VMHooksEarlyExit>

fn small_int_get_signed_argument( &mut self, id: i32, ) -> Result<i64, VMHooksEarlyExit>

fn small_int_finish_unsigned( &mut self, value: i64, ) -> Result<(), VMHooksEarlyExit>

fn small_int_finish_signed( &mut self, value: i64, ) -> Result<(), VMHooksEarlyExit>

fn small_int_storage_store_unsigned( &mut self, key_offset: MemPtr, key_length: MemLength, value: i64, ) -> Result<i32, VMHooksEarlyExit>

fn small_int_storage_store_signed( &mut self, key_offset: MemPtr, key_length: MemLength, value: i64, ) -> Result<i32, VMHooksEarlyExit>

fn small_int_storage_load_unsigned( &mut self, key_offset: MemPtr, key_length: MemLength, ) -> Result<i64, VMHooksEarlyExit>

fn small_int_storage_load_signed( &mut self, key_offset: MemPtr, key_length: MemLength, ) -> Result<i64, VMHooksEarlyExit>

fn int64get_argument(&mut self, id: i32) -> Result<i64, VMHooksEarlyExit>

fn int64finish(&mut self, value: i64) -> Result<(), VMHooksEarlyExit>

fn int64storage_store( &mut self, key_offset: MemPtr, key_length: MemLength, value: i64, ) -> Result<i32, VMHooksEarlyExit>

fn int64storage_load( &mut self, key_offset: MemPtr, key_length: MemLength, ) -> Result<i64, VMHooksEarlyExit>

fn sha256( &mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn managed_sha256( &mut self, input_handle: i32, output_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn keccak256( &mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn managed_keccak256( &mut self, input_handle: i32, output_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn ripemd160( &mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn managed_ripemd160( &mut self, input_handle: i32, output_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn verify_bls( &mut self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn managed_verify_bls( &mut self, key_handle: i32, message_handle: i32, sig_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn verify_ed25519( &mut self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn managed_verify_ed25519( &mut self, key_handle: i32, message_handle: i32, sig_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn verify_custom_secp256k1( &mut self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr, hash_type: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_verify_custom_secp256k1( &mut self, key_handle: i32, message_handle: i32, sig_handle: i32, hash_type: i32, ) -> Result<i32, VMHooksEarlyExit>

fn verify_secp256k1( &mut self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn managed_verify_secp256k1( &mut self, key_handle: i32, message_handle: i32, sig_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn encode_secp256k1_der_signature( &mut self, r_offset: MemPtr, r_length: MemLength, s_offset: MemPtr, s_length: MemLength, sig_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn managed_encode_secp256k1_der_signature( &mut self, r_handle: i32, s_handle: i32, sig_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn add_ec( &mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, fst_point_xhandle: i32, fst_point_yhandle: i32, snd_point_xhandle: i32, snd_point_yhandle: i32, ) -> Result<(), VMHooksEarlyExit>

fn double_ec( &mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32, ) -> Result<(), VMHooksEarlyExit>

fn is_on_curve_ec( &mut self, ec_handle: i32, point_xhandle: i32, point_yhandle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn scalar_base_mult_ec( &mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength, ) -> Result<i32, VMHooksEarlyExit>

fn managed_scalar_base_mult_ec( &mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn scalar_mult_ec( &mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32, data_offset: MemPtr, length: MemLength, ) -> Result<i32, VMHooksEarlyExit>

fn managed_scalar_mult_ec( &mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32, data_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn marshal_ec( &mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn managed_marshal_ec( &mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn marshal_compressed_ec( &mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn managed_marshal_compressed_ec( &mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn unmarshal_ec( &mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength, ) -> Result<i32, VMHooksEarlyExit>

fn managed_unmarshal_ec( &mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn unmarshal_compressed_ec( &mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength, ) -> Result<i32, VMHooksEarlyExit>

fn managed_unmarshal_compressed_ec( &mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn generate_key_ec( &mut self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_offset: MemPtr, ) -> Result<i32, VMHooksEarlyExit>

fn managed_generate_key_ec( &mut self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn create_ec( &mut self, data_offset: MemPtr, data_length: MemLength, ) -> Result<i32, VMHooksEarlyExit>

fn managed_create_ec( &mut self, data_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn get_curve_length_ec( &mut self, ec_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn get_priv_key_byte_length_ec( &mut self, ec_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn elliptic_curve_get_values( &mut self, ec_handle: i32, field_order_handle: i32, base_point_order_handle: i32, eq_constant_handle: i32, x_base_point_handle: i32, y_base_point_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn is_reserved_function_name( &mut self, name_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_get_original_caller_addr( &mut self, destination_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_get_relayer_addr( &mut self, destination_handle: i32, ) -> Result<(), VMHooksEarlyExit>

fn managed_multi_transfer_esdt_nft_execute_by_user( &mut self, user_handle: i32, dst_handle: i32, token_transfers_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_verify_secp256r1( &mut self, key_handle: i32, message_handle: i32, sig_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_verify_blssignature_share( &mut self, key_handle: i32, message_handle: i32, sig_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

fn managed_verify_blsaggregated_signature( &mut self, key_handle: i32, message_handle: i32, sig_handle: i32, ) -> Result<i32, VMHooksEarlyExit>

impl<S> VMHooksSetEarlyExit for VMHooksDispatcher<TxVMHooksContext<S>>

where S: InstanceStateSetEarlyExit,

fn set_early_exit(&self, early_exit: VMHooksEarlyExit)