diff --git a/.github/workflows/libvmexeccapi-build-linux-arm64.yml b/.github/workflows/libvmexeccapi-build-linux-arm64.yml index 66cfdeb..f5094af 100644 --- a/.github/workflows/libvmexeccapi-build-linux-arm64.yml +++ b/.github/workflows/libvmexeccapi-build-linux-arm64.yml @@ -10,7 +10,7 @@ on: jobs: build: name: Build library for Linux ARM64 - runs-on: ubuntu-latest + runs-on: [ubuntu-22.04] steps: - name: Check out code uses: actions/checkout@v4 @@ -38,7 +38,7 @@ jobs: - name: Save artifacts uses: actions/upload-artifact@v4 with: - name: artifacts-linux-arm64 + name: lib-linux-arm path: | libvmexeccapi_arm.so if-no-files-found: error diff --git a/.github/workflows/libvmexeccapi-build.yml b/.github/workflows/libvmexeccapi-build.yml index 74d8a02..12a6b1f 100644 --- a/.github/workflows/libvmexeccapi-build.yml +++ b/.github/workflows/libvmexeccapi-build.yml @@ -16,7 +16,7 @@ jobs: strategy: matrix: include: - - os: ubuntu-20.04 + - os: ubuntu-22.04 artifact_name: libvmexeccapi.so make_target: capi-linux-amd64 - os: macos-13 @@ -29,7 +29,7 @@ jobs: - name: Install rust uses: actions-rust-lang/setup-rust-toolchain@v1 with: - toolchain: "1.77" + toolchain: "1.83" - name: Checkout uses: actions/checkout@v4 @@ -38,9 +38,9 @@ jobs: run: make ${{ matrix.make_target }} - name: Save artifacts - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: - name: libs + name: lib-${{ matrix.make_target }} path: | target/release/*.so target/release/*.dylib diff --git a/.github/workflows/rust-ci.yml b/.github/workflows/rust-ci.yml index 2210ed6..21da948 100644 --- a/.github/workflows/rust-ci.yml +++ b/.github/workflows/rust-ci.yml @@ -15,9 +15,9 @@ jobs: - uses: actions-rs/toolchain@v1 with: default: true - toolchain: "1.77" + toolchain: "1.83" - name: Run rust tests - run: cargo +1.77 test + run: cargo +1.83 test --release clippy_check: permissions: write-all name: Clippy linter check diff --git a/Cargo.toml b/Cargo.toml index 9f3d5e9..4bb2973 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,5 +5,6 @@ members = [ "meta", "c-api", "vm-executor", + "vm-executor-experimental", "vm-executor-wasmer", ] diff --git a/c-api/libvmexeccapi.h b/c-api/libvmexeccapi.h index f4f989a..802beac 100644 --- a/c-api/libvmexeccapi.h +++ b/c-api/libvmexeccapi.h @@ -411,7 +411,7 @@ vm_exec_result_t vm_exec_instance_from_cache(vm_exec_executor_t *executor_ptr, * * C API function, works with raw object pointers. */ -uint64_t vm_exec_instance_get_breakpoint_value(const vm_exec_instance_t *instance_ptr); +uint64_t vm_exec_instance_get_breakpoint_value(vm_exec_instance_t *instance_ptr); /** * Returns the number of points(gas) used by the given instance. @@ -492,7 +492,7 @@ vm_exec_result_t vm_exec_instance_reset(vm_exec_instance_t *instance_ptr); * * C API function, works with raw object pointers. */ -vm_exec_result_t vm_exec_instance_set_breakpoint_value(const vm_exec_instance_t *instance_ptr, +vm_exec_result_t vm_exec_instance_set_breakpoint_value(vm_exec_instance_t *instance_ptr, uint64_t value); /** diff --git a/c-api/src/capi_breakpoints.rs b/c-api/src/capi_breakpoints.rs index 532933b..46016aa 100644 --- a/c-api/src/capi_breakpoints.rs +++ b/c-api/src/capi_breakpoints.rs @@ -1,5 +1,5 @@ use meta::capi_safe_unwind; -use multiversx_chain_vm_executor::Instance; +use multiversx_chain_vm_executor::InstanceLegacy; use crate::capi_instance::{vm_exec_instance_t, CapiInstance}; use crate::service_singleton::with_service; @@ -18,11 +18,11 @@ use crate::vm_exec_result_t; #[no_mangle] #[capi_safe_unwind(vm_exec_result_t::VM_EXEC_ERROR)] pub unsafe extern "C" fn vm_exec_instance_set_breakpoint_value( - instance_ptr: *const vm_exec_instance_t, + instance_ptr: *mut vm_exec_instance_t, value: u64, ) -> vm_exec_result_t { - let capi_instance = cast_input_const_ptr!(instance_ptr, CapiInstance, "instance ptr is null"); - let result = set_breakpoint_value_u64(capi_instance.content.as_ref(), value); + let capi_instance = cast_input_ptr!(instance_ptr, CapiInstance, "instance ptr is null"); + let result = set_breakpoint_value_u64(capi_instance.content.as_mut(), value); match result { Ok(()) => vm_exec_result_t::VM_EXEC_OK, Err(message) => { @@ -41,10 +41,9 @@ pub unsafe extern "C" fn vm_exec_instance_set_breakpoint_value( #[no_mangle] #[capi_safe_unwind(0)] pub unsafe extern "C" fn vm_exec_instance_get_breakpoint_value( - instance_ptr: *const vm_exec_instance_t, + instance_ptr: *mut vm_exec_instance_t, ) -> u64 { - let capi_instance = - cast_input_const_ptr!(instance_ptr, CapiInstance, "instance ptr is null", 0); + let capi_instance = cast_input_ptr!(instance_ptr, CapiInstance, "instance ptr is null", 0); let result = capi_instance.content.get_breakpoint_value(); match result { Ok(breakpoint_value) => breakpoint_value.as_u64(), @@ -55,6 +54,6 @@ pub unsafe extern "C" fn vm_exec_instance_get_breakpoint_value( } } -fn set_breakpoint_value_u64(instance: &dyn Instance, value: u64) -> Result<(), String> { +fn set_breakpoint_value_u64(instance: &mut dyn InstanceLegacy, value: u64) -> Result<(), String> { instance.set_breakpoint_value(value.try_into()?) } diff --git a/c-api/src/capi_executor.rs b/c-api/src/capi_executor.rs index 0cbcfc0..14ab0ce 100644 --- a/c-api/src/capi_executor.rs +++ b/c-api/src/capi_executor.rs @@ -6,7 +6,7 @@ use crate::{ }; use libc::c_void; use meta::capi_safe_unwind; -use multiversx_chain_vm_executor::Executor; +use multiversx_chain_vm_executor::ExecutorLegacy; use multiversx_chain_vm_executor_wasmer::force_sighandler_reinstall; #[allow(non_camel_case_types)] @@ -14,7 +14,7 @@ use multiversx_chain_vm_executor_wasmer::force_sighandler_reinstall; pub struct vm_exec_executor_t; pub struct CapiExecutor { - pub content: Box, + pub content: Box, } /// Creates a new VM executor. diff --git a/c-api/src/capi_instance.rs b/c-api/src/capi_instance.rs index 25af31e..1f321d6 100644 --- a/c-api/src/capi_instance.rs +++ b/c-api/src/capi_instance.rs @@ -5,9 +5,9 @@ use crate::{ service_singleton::with_service, string_copy, vm_exec_result_t, }; -use meta::capi_safe_unwind; use libc::{c_char, c_int}; -use multiversx_chain_vm_executor::{CompilationOptions, Instance}; +use meta::capi_safe_unwind; +use multiversx_chain_vm_executor::{CompilationOptions, InstanceLegacy}; use std::{ffi::CStr, slice}; /// Opaque pointer to a `wasmer_runtime::Instance` value in Rust. @@ -24,7 +24,7 @@ pub struct vm_exec_instance_t; pub struct vm_exec_compilation_options_t; pub struct CapiInstance { - pub(crate) content: Box, + pub(crate) content: Box, } /// Creates a new VM executor instance. diff --git a/c-api/src/capi_vm_hook_pointers.rs b/c-api/src/capi_vm_hook_pointers.rs index 4202ec0..faaab6b 100644 --- a/c-api/src/capi_vm_hook_pointers.rs +++ b/c-api/src/capi_vm_hook_pointers.rs @@ -8,6 +8,7 @@ use std::ffi::c_void; #[repr(C)] #[derive(Clone)] +#[allow(non_camel_case_types)] #[rustfmt::skip] pub struct vm_exec_vm_hook_c_func_pointers { pub get_gas_left_func_ptr: extern "C" fn(context: *mut c_void) -> i64, diff --git a/c-api/src/capi_vm_hooks.rs b/c-api/src/capi_vm_hooks.rs index 53659c4..193b9e8 100644 --- a/c-api/src/capi_vm_hooks.rs +++ b/c-api/src/capi_vm_hooks.rs @@ -24,1066 +24,1066 @@ impl CapiVMHooks { } } - fn convert_mem_ptr(&self, mem_ptr: MemPtr) -> i32 { + fn convert_mem_ptr(&mut self, mem_ptr: MemPtr) -> i32 { mem_ptr as i32 } - fn convert_mem_length(&self, mem_length: MemLength) -> i32 { + fn convert_mem_length(&mut self, mem_length: MemLength) -> i32 { mem_length as i32 } } #[rustfmt::skip] -impl multiversx_chain_vm_executor::VMHooks for CapiVMHooks { +impl multiversx_chain_vm_executor::VMHooksLegacy for CapiVMHooks { fn set_vm_hooks_ptr(&mut self, vm_hooks_ptr: *mut c_void) { self.vm_hooks_ptr = vm_hooks_ptr; } - fn get_gas_left(&self) -> i64 { + fn get_gas_left(&mut self) -> i64 { (self.c_func_pointers_ptr.get_gas_left_func_ptr)(self.vm_hooks_ptr) } - fn get_sc_address(&self, result_offset: MemPtr) { + fn get_sc_address(&mut self, result_offset: MemPtr) { (self.c_func_pointers_ptr.get_sc_address_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(result_offset)) } - fn get_owner_address(&self, result_offset: MemPtr) { + fn get_owner_address(&mut self, result_offset: MemPtr) { (self.c_func_pointers_ptr.get_owner_address_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(result_offset)) } - fn get_shard_of_address(&self, address_offset: MemPtr) -> i32 { + fn get_shard_of_address(&mut self, address_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.get_shard_of_address_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(address_offset)) } - fn is_smart_contract(&self, address_offset: MemPtr) -> i32 { + fn is_smart_contract(&mut self, address_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.is_smart_contract_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(address_offset)) } - fn signal_error(&self, message_offset: MemPtr, message_length: MemLength) { + fn signal_error(&mut self, message_offset: MemPtr, message_length: MemLength) { (self.c_func_pointers_ptr.signal_error_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(message_offset), self.convert_mem_length(message_length)) } - fn get_external_balance(&self, address_offset: MemPtr, result_offset: MemPtr) { + fn get_external_balance(&mut self, address_offset: MemPtr, result_offset: MemPtr) { (self.c_func_pointers_ptr.get_external_balance_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(address_offset), self.convert_mem_ptr(result_offset)) } - fn get_block_hash(&self, nonce: i64, result_offset: MemPtr) -> i32 { + fn get_block_hash(&mut self, nonce: i64, result_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.get_block_hash_func_ptr)(self.vm_hooks_ptr, nonce, self.convert_mem_ptr(result_offset)) } - fn get_esdt_balance(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, result_offset: MemPtr) -> i32 { + fn get_esdt_balance(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, result_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.get_esdt_balance_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(address_offset), self.convert_mem_ptr(token_id_offset), self.convert_mem_length(token_id_len), nonce, self.convert_mem_ptr(result_offset)) } - fn get_esdt_nft_name_length(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32 { + fn get_esdt_nft_name_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32 { (self.c_func_pointers_ptr.get_esdt_nft_name_length_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(address_offset), self.convert_mem_ptr(token_id_offset), self.convert_mem_length(token_id_len), nonce) } - fn get_esdt_nft_attribute_length(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32 { + fn get_esdt_nft_attribute_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32 { (self.c_func_pointers_ptr.get_esdt_nft_attribute_length_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(address_offset), self.convert_mem_ptr(token_id_offset), self.convert_mem_length(token_id_len), nonce) } - fn get_esdt_nft_uri_length(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32 { + fn get_esdt_nft_uri_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32 { (self.c_func_pointers_ptr.get_esdt_nft_uri_length_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(address_offset), self.convert_mem_ptr(token_id_offset), self.convert_mem_length(token_id_len), nonce) } - fn get_esdt_token_data(&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) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.get_esdt_token_data_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(address_offset), self.convert_mem_ptr(token_id_offset), self.convert_mem_length(token_id_len), nonce, value_handle, self.convert_mem_ptr(properties_offset), self.convert_mem_ptr(hash_offset), self.convert_mem_ptr(name_offset), self.convert_mem_ptr(attributes_offset), self.convert_mem_ptr(creator_offset), royalties_handle, self.convert_mem_ptr(uris_offset)) } - fn get_esdt_local_roles(&self, token_id_handle: i32) -> i64 { + fn get_esdt_local_roles(&mut self, token_id_handle: i32) -> i64 { (self.c_func_pointers_ptr.get_esdt_local_roles_func_ptr)(self.vm_hooks_ptr, token_id_handle) } - fn validate_token_identifier(&self, token_id_handle: i32) -> i32 { + fn validate_token_identifier(&mut self, token_id_handle: i32) -> i32 { (self.c_func_pointers_ptr.validate_token_identifier_func_ptr)(self.vm_hooks_ptr, token_id_handle) } - fn transfer_value(&self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength) -> i32 { + fn transfer_value(&mut self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength) -> i32 { (self.c_func_pointers_ptr.transfer_value_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(dest_offset), self.convert_mem_ptr(value_offset), self.convert_mem_ptr(data_offset), self.convert_mem_length(length)) } - fn transfer_value_execute(&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) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.transfer_value_execute_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(dest_offset), self.convert_mem_ptr(value_offset), gas_limit, self.convert_mem_ptr(function_offset), self.convert_mem_length(function_length), num_arguments, self.convert_mem_ptr(arguments_length_offset), self.convert_mem_ptr(data_offset)) } - fn transfer_esdt_execute(&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) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.transfer_esdt_execute_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(dest_offset), self.convert_mem_ptr(token_id_offset), self.convert_mem_length(token_id_len), self.convert_mem_ptr(value_offset), gas_limit, self.convert_mem_ptr(function_offset), self.convert_mem_length(function_length), num_arguments, self.convert_mem_ptr(arguments_length_offset), self.convert_mem_ptr(data_offset)) } - fn transfer_esdt_nft_execute(&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) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.transfer_esdt_nft_execute_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(dest_offset), self.convert_mem_ptr(token_id_offset), self.convert_mem_length(token_id_len), self.convert_mem_ptr(value_offset), nonce, gas_limit, self.convert_mem_ptr(function_offset), self.convert_mem_length(function_length), num_arguments, self.convert_mem_ptr(arguments_length_offset), self.convert_mem_ptr(data_offset)) } - fn multi_transfer_esdt_nft_execute(&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) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.multi_transfer_esdt_nft_execute_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(dest_offset), num_token_transfers, self.convert_mem_ptr(token_transfers_args_length_offset), self.convert_mem_ptr(token_transfer_data_offset), gas_limit, self.convert_mem_ptr(function_offset), self.convert_mem_length(function_length), num_arguments, self.convert_mem_ptr(arguments_length_offset), self.convert_mem_ptr(data_offset)) } - fn create_async_call(&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) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.create_async_call_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(dest_offset), self.convert_mem_ptr(value_offset), self.convert_mem_ptr(data_offset), self.convert_mem_length(data_length), self.convert_mem_ptr(success_offset), self.convert_mem_length(success_length), self.convert_mem_ptr(error_offset), self.convert_mem_length(error_length), gas, extra_gas_for_callback) } - fn set_async_context_callback(&self, callback: MemPtr, callback_length: MemLength, data: MemPtr, data_length: MemLength, gas: i64) -> i32 { + fn set_async_context_callback(&mut self, callback: MemPtr, callback_length: MemLength, data: MemPtr, data_length: MemLength, gas: i64) -> i32 { (self.c_func_pointers_ptr.set_async_context_callback_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(callback), self.convert_mem_length(callback_length), self.convert_mem_ptr(data), self.convert_mem_length(data_length), gas) } - fn upgrade_contract(&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) { + 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) { (self.c_func_pointers_ptr.upgrade_contract_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(dest_offset), gas_limit, self.convert_mem_ptr(value_offset), self.convert_mem_ptr(code_offset), self.convert_mem_ptr(code_metadata_offset), self.convert_mem_length(length), num_arguments, self.convert_mem_ptr(arguments_length_offset), self.convert_mem_ptr(data_offset)) } - fn upgrade_from_source_contract(&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) { + 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) { (self.c_func_pointers_ptr.upgrade_from_source_contract_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(dest_offset), gas_limit, self.convert_mem_ptr(value_offset), self.convert_mem_ptr(source_contract_address_offset), self.convert_mem_ptr(code_metadata_offset), num_arguments, self.convert_mem_ptr(arguments_length_offset), self.convert_mem_ptr(data_offset)) } - fn delete_contract(&self, dest_offset: MemPtr, gas_limit: i64, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr) { + fn delete_contract(&mut self, dest_offset: MemPtr, gas_limit: i64, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr) { (self.c_func_pointers_ptr.delete_contract_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(dest_offset), gas_limit, num_arguments, self.convert_mem_ptr(arguments_length_offset), self.convert_mem_ptr(data_offset)) } - fn async_call(&self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength) { + fn async_call(&mut self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength) { (self.c_func_pointers_ptr.async_call_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(dest_offset), self.convert_mem_ptr(value_offset), self.convert_mem_ptr(data_offset), self.convert_mem_length(length)) } - fn get_argument_length(&self, id: i32) -> i32 { + fn get_argument_length(&mut self, id: i32) -> i32 { (self.c_func_pointers_ptr.get_argument_length_func_ptr)(self.vm_hooks_ptr, id) } - fn get_argument(&self, id: i32, arg_offset: MemPtr) -> i32 { + fn get_argument(&mut self, id: i32, arg_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.get_argument_func_ptr)(self.vm_hooks_ptr, id, self.convert_mem_ptr(arg_offset)) } - fn get_function(&self, function_offset: MemPtr) -> i32 { + fn get_function(&mut self, function_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.get_function_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(function_offset)) } - fn get_num_arguments(&self) -> i32 { + fn get_num_arguments(&mut self) -> i32 { (self.c_func_pointers_ptr.get_num_arguments_func_ptr)(self.vm_hooks_ptr) } - fn storage_store(&self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr, data_length: MemLength) -> i32 { + fn storage_store(&mut self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr, data_length: MemLength) -> i32 { (self.c_func_pointers_ptr.storage_store_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length), self.convert_mem_ptr(data_offset), self.convert_mem_length(data_length)) } - fn storage_load_length(&self, key_offset: MemPtr, key_length: MemLength) -> i32 { + fn storage_load_length(&mut self, key_offset: MemPtr, key_length: MemLength) -> i32 { (self.c_func_pointers_ptr.storage_load_length_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length)) } - fn storage_load_from_address(&self, address_offset: MemPtr, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> i32 { + fn storage_load_from_address(&mut self, address_offset: MemPtr, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.storage_load_from_address_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(address_offset), self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length), self.convert_mem_ptr(data_offset)) } - fn storage_load(&self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> i32 { + fn storage_load(&mut self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.storage_load_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length), self.convert_mem_ptr(data_offset)) } - fn set_storage_lock(&self, key_offset: MemPtr, key_length: MemLength, lock_timestamp: i64) -> i32 { + fn set_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength, lock_timestamp: i64) -> i32 { (self.c_func_pointers_ptr.set_storage_lock_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length), lock_timestamp) } - fn get_storage_lock(&self, key_offset: MemPtr, key_length: MemLength) -> i64 { + fn get_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength) -> i64 { (self.c_func_pointers_ptr.get_storage_lock_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length)) } - fn is_storage_locked(&self, key_offset: MemPtr, key_length: MemLength) -> i32 { + fn is_storage_locked(&mut self, key_offset: MemPtr, key_length: MemLength) -> i32 { (self.c_func_pointers_ptr.is_storage_locked_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length)) } - fn clear_storage_lock(&self, key_offset: MemPtr, key_length: MemLength) -> i32 { + fn clear_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength) -> i32 { (self.c_func_pointers_ptr.clear_storage_lock_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length)) } - fn get_caller(&self, result_offset: MemPtr) { + fn get_caller(&mut self, result_offset: MemPtr) { (self.c_func_pointers_ptr.get_caller_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(result_offset)) } - fn check_no_payment(&self) { + fn check_no_payment(&mut self) { (self.c_func_pointers_ptr.check_no_payment_func_ptr)(self.vm_hooks_ptr) } - fn get_call_value(&self, result_offset: MemPtr) -> i32 { + fn get_call_value(&mut self, result_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.get_call_value_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(result_offset)) } - fn get_esdt_value(&self, result_offset: MemPtr) -> i32 { + fn get_esdt_value(&mut self, result_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.get_esdt_value_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(result_offset)) } - fn get_esdt_value_by_index(&self, result_offset: MemPtr, index: i32) -> i32 { + fn get_esdt_value_by_index(&mut self, result_offset: MemPtr, index: i32) -> i32 { (self.c_func_pointers_ptr.get_esdt_value_by_index_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(result_offset), index) } - fn get_esdt_token_name(&self, result_offset: MemPtr) -> i32 { + fn get_esdt_token_name(&mut self, result_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.get_esdt_token_name_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(result_offset)) } - fn get_esdt_token_name_by_index(&self, result_offset: MemPtr, index: i32) -> i32 { + fn get_esdt_token_name_by_index(&mut self, result_offset: MemPtr, index: i32) -> i32 { (self.c_func_pointers_ptr.get_esdt_token_name_by_index_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(result_offset), index) } - fn get_esdt_token_nonce(&self) -> i64 { + fn get_esdt_token_nonce(&mut self) -> i64 { (self.c_func_pointers_ptr.get_esdt_token_nonce_func_ptr)(self.vm_hooks_ptr) } - fn get_esdt_token_nonce_by_index(&self, index: i32) -> i64 { + fn get_esdt_token_nonce_by_index(&mut self, index: i32) -> i64 { (self.c_func_pointers_ptr.get_esdt_token_nonce_by_index_func_ptr)(self.vm_hooks_ptr, index) } - fn get_current_esdt_nft_nonce(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength) -> i64 { + fn get_current_esdt_nft_nonce(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength) -> i64 { (self.c_func_pointers_ptr.get_current_esdt_nft_nonce_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(address_offset), self.convert_mem_ptr(token_id_offset), self.convert_mem_length(token_id_len)) } - fn get_esdt_token_type(&self) -> i32 { + fn get_esdt_token_type(&mut self) -> i32 { (self.c_func_pointers_ptr.get_esdt_token_type_func_ptr)(self.vm_hooks_ptr) } - fn get_esdt_token_type_by_index(&self, index: i32) -> i32 { + fn get_esdt_token_type_by_index(&mut self, index: i32) -> i32 { (self.c_func_pointers_ptr.get_esdt_token_type_by_index_func_ptr)(self.vm_hooks_ptr, index) } - fn get_num_esdt_transfers(&self) -> i32 { + fn get_num_esdt_transfers(&mut self) -> i32 { (self.c_func_pointers_ptr.get_num_esdt_transfers_func_ptr)(self.vm_hooks_ptr) } - fn get_call_value_token_name(&self, call_value_offset: MemPtr, token_name_offset: MemPtr) -> i32 { + fn get_call_value_token_name(&mut self, call_value_offset: MemPtr, token_name_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.get_call_value_token_name_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(call_value_offset), self.convert_mem_ptr(token_name_offset)) } - fn get_call_value_token_name_by_index(&self, call_value_offset: MemPtr, token_name_offset: MemPtr, index: i32) -> i32 { + fn get_call_value_token_name_by_index(&mut self, call_value_offset: MemPtr, token_name_offset: MemPtr, index: i32) -> i32 { (self.c_func_pointers_ptr.get_call_value_token_name_by_index_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(call_value_offset), self.convert_mem_ptr(token_name_offset), index) } - fn is_reserved_function_name(&self, name_handle: i32) -> i32 { + fn is_reserved_function_name(&mut self, name_handle: i32) -> i32 { (self.c_func_pointers_ptr.is_reserved_function_name_func_ptr)(self.vm_hooks_ptr, name_handle) } - fn write_log(&self, data_pointer: MemPtr, data_length: MemLength, topic_ptr: MemPtr, num_topics: i32) { + fn write_log(&mut self, data_pointer: MemPtr, data_length: MemLength, topic_ptr: MemPtr, num_topics: i32) { (self.c_func_pointers_ptr.write_log_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(data_pointer), self.convert_mem_length(data_length), self.convert_mem_ptr(topic_ptr), num_topics) } - fn write_event_log(&self, num_topics: i32, topic_lengths_offset: MemPtr, topic_offset: MemPtr, data_offset: MemPtr, data_length: MemLength) { + fn write_event_log(&mut self, num_topics: i32, topic_lengths_offset: MemPtr, topic_offset: MemPtr, data_offset: MemPtr, data_length: MemLength) { (self.c_func_pointers_ptr.write_event_log_func_ptr)(self.vm_hooks_ptr, num_topics, self.convert_mem_ptr(topic_lengths_offset), self.convert_mem_ptr(topic_offset), self.convert_mem_ptr(data_offset), self.convert_mem_length(data_length)) } - fn get_block_timestamp(&self) -> i64 { + fn get_block_timestamp(&mut self) -> i64 { (self.c_func_pointers_ptr.get_block_timestamp_func_ptr)(self.vm_hooks_ptr) } - fn get_block_nonce(&self) -> i64 { + fn get_block_nonce(&mut self) -> i64 { (self.c_func_pointers_ptr.get_block_nonce_func_ptr)(self.vm_hooks_ptr) } - fn get_block_round(&self) -> i64 { + fn get_block_round(&mut self) -> i64 { (self.c_func_pointers_ptr.get_block_round_func_ptr)(self.vm_hooks_ptr) } - fn get_block_epoch(&self) -> i64 { + fn get_block_epoch(&mut self) -> i64 { (self.c_func_pointers_ptr.get_block_epoch_func_ptr)(self.vm_hooks_ptr) } - fn get_block_random_seed(&self, pointer: MemPtr) { + fn get_block_random_seed(&mut self, pointer: MemPtr) { (self.c_func_pointers_ptr.get_block_random_seed_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(pointer)) } - fn get_state_root_hash(&self, pointer: MemPtr) { + fn get_state_root_hash(&mut self, pointer: MemPtr) { (self.c_func_pointers_ptr.get_state_root_hash_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(pointer)) } - fn get_prev_block_timestamp(&self) -> i64 { + fn get_prev_block_timestamp(&mut self) -> i64 { (self.c_func_pointers_ptr.get_prev_block_timestamp_func_ptr)(self.vm_hooks_ptr) } - fn get_prev_block_nonce(&self) -> i64 { + fn get_prev_block_nonce(&mut self) -> i64 { (self.c_func_pointers_ptr.get_prev_block_nonce_func_ptr)(self.vm_hooks_ptr) } - fn get_prev_block_round(&self) -> i64 { + fn get_prev_block_round(&mut self) -> i64 { (self.c_func_pointers_ptr.get_prev_block_round_func_ptr)(self.vm_hooks_ptr) } - fn get_prev_block_epoch(&self) -> i64 { + fn get_prev_block_epoch(&mut self) -> i64 { (self.c_func_pointers_ptr.get_prev_block_epoch_func_ptr)(self.vm_hooks_ptr) } - fn get_prev_block_random_seed(&self, pointer: MemPtr) { + fn get_prev_block_random_seed(&mut self, pointer: MemPtr) { (self.c_func_pointers_ptr.get_prev_block_random_seed_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(pointer)) } - fn finish(&self, pointer: MemPtr, length: MemLength) { + fn finish(&mut self, pointer: MemPtr, length: MemLength) { (self.c_func_pointers_ptr.finish_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(pointer), self.convert_mem_length(length)) } - fn execute_on_same_context(&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) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.execute_on_same_context_func_ptr)(self.vm_hooks_ptr, gas_limit, self.convert_mem_ptr(address_offset), self.convert_mem_ptr(value_offset), self.convert_mem_ptr(function_offset), self.convert_mem_length(function_length), num_arguments, self.convert_mem_ptr(arguments_length_offset), self.convert_mem_ptr(data_offset)) } - fn execute_on_dest_context(&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) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.execute_on_dest_context_func_ptr)(self.vm_hooks_ptr, gas_limit, self.convert_mem_ptr(address_offset), self.convert_mem_ptr(value_offset), self.convert_mem_ptr(function_offset), self.convert_mem_length(function_length), num_arguments, self.convert_mem_ptr(arguments_length_offset), self.convert_mem_ptr(data_offset)) } - fn execute_read_only(&self, gas_limit: i64, address_offset: MemPtr, function_offset: MemPtr, function_length: MemLength, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.execute_read_only_func_ptr)(self.vm_hooks_ptr, gas_limit, self.convert_mem_ptr(address_offset), self.convert_mem_ptr(function_offset), self.convert_mem_length(function_length), num_arguments, self.convert_mem_ptr(arguments_length_offset), self.convert_mem_ptr(data_offset)) } - fn create_contract(&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) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.create_contract_func_ptr)(self.vm_hooks_ptr, gas_limit, self.convert_mem_ptr(value_offset), self.convert_mem_ptr(code_offset), self.convert_mem_ptr(code_metadata_offset), self.convert_mem_length(length), self.convert_mem_ptr(result_offset), num_arguments, self.convert_mem_ptr(arguments_length_offset), self.convert_mem_ptr(data_offset)) } - fn deploy_from_source_contract(&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) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.deploy_from_source_contract_func_ptr)(self.vm_hooks_ptr, gas_limit, self.convert_mem_ptr(value_offset), self.convert_mem_ptr(source_contract_address_offset), self.convert_mem_ptr(code_metadata_offset), self.convert_mem_ptr(result_address_offset), num_arguments, self.convert_mem_ptr(arguments_length_offset), self.convert_mem_ptr(data_offset)) } - fn get_num_return_data(&self) -> i32 { + fn get_num_return_data(&mut self) -> i32 { (self.c_func_pointers_ptr.get_num_return_data_func_ptr)(self.vm_hooks_ptr) } - fn get_return_data_size(&self, result_id: i32) -> i32 { + fn get_return_data_size(&mut self, result_id: i32) -> i32 { (self.c_func_pointers_ptr.get_return_data_size_func_ptr)(self.vm_hooks_ptr, result_id) } - fn get_return_data(&self, result_id: i32, data_offset: MemPtr) -> i32 { + fn get_return_data(&mut self, result_id: i32, data_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.get_return_data_func_ptr)(self.vm_hooks_ptr, result_id, self.convert_mem_ptr(data_offset)) } - fn clean_return_data(&self) { + fn clean_return_data(&mut self) { (self.c_func_pointers_ptr.clean_return_data_func_ptr)(self.vm_hooks_ptr) } - fn delete_from_return_data(&self, result_id: i32) { + fn delete_from_return_data(&mut self, result_id: i32) { (self.c_func_pointers_ptr.delete_from_return_data_func_ptr)(self.vm_hooks_ptr, result_id) } - fn get_original_tx_hash(&self, data_offset: MemPtr) { + fn get_original_tx_hash(&mut self, data_offset: MemPtr) { (self.c_func_pointers_ptr.get_original_tx_hash_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(data_offset)) } - fn get_current_tx_hash(&self, data_offset: MemPtr) { + fn get_current_tx_hash(&mut self, data_offset: MemPtr) { (self.c_func_pointers_ptr.get_current_tx_hash_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(data_offset)) } - fn get_prev_tx_hash(&self, data_offset: MemPtr) { + fn get_prev_tx_hash(&mut self, data_offset: MemPtr) { (self.c_func_pointers_ptr.get_prev_tx_hash_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(data_offset)) } - fn managed_sc_address(&self, destination_handle: i32) { + fn managed_sc_address(&mut self, destination_handle: i32) { (self.c_func_pointers_ptr.managed_sc_address_func_ptr)(self.vm_hooks_ptr, destination_handle) } - fn managed_owner_address(&self, destination_handle: i32) { + fn managed_owner_address(&mut self, destination_handle: i32) { (self.c_func_pointers_ptr.managed_owner_address_func_ptr)(self.vm_hooks_ptr, destination_handle) } - fn managed_caller(&self, destination_handle: i32) { + fn managed_caller(&mut self, destination_handle: i32) { (self.c_func_pointers_ptr.managed_caller_func_ptr)(self.vm_hooks_ptr, destination_handle) } - fn managed_get_original_caller_addr(&self, destination_handle: i32) { + fn managed_get_original_caller_addr(&mut self, destination_handle: i32) { (self.c_func_pointers_ptr.managed_get_original_caller_addr_func_ptr)(self.vm_hooks_ptr, destination_handle) } - fn managed_get_relayer_addr(&self, destination_handle: i32) { + fn managed_get_relayer_addr(&mut self, destination_handle: i32) { (self.c_func_pointers_ptr.managed_get_relayer_addr_func_ptr)(self.vm_hooks_ptr, destination_handle) } - fn managed_signal_error(&self, err_handle: i32) { + fn managed_signal_error(&mut self, err_handle: i32) { (self.c_func_pointers_ptr.managed_signal_error_func_ptr)(self.vm_hooks_ptr, err_handle) } - fn managed_write_log(&self, topics_handle: i32, data_handle: i32) { + fn managed_write_log(&mut self, topics_handle: i32, data_handle: i32) { (self.c_func_pointers_ptr.managed_write_log_func_ptr)(self.vm_hooks_ptr, topics_handle, data_handle) } - fn managed_get_original_tx_hash(&self, result_handle: i32) { + fn managed_get_original_tx_hash(&mut self, result_handle: i32) { (self.c_func_pointers_ptr.managed_get_original_tx_hash_func_ptr)(self.vm_hooks_ptr, result_handle) } - fn managed_get_state_root_hash(&self, result_handle: i32) { + fn managed_get_state_root_hash(&mut self, result_handle: i32) { (self.c_func_pointers_ptr.managed_get_state_root_hash_func_ptr)(self.vm_hooks_ptr, result_handle) } - fn managed_get_block_random_seed(&self, result_handle: i32) { + fn managed_get_block_random_seed(&mut self, result_handle: i32) { (self.c_func_pointers_ptr.managed_get_block_random_seed_func_ptr)(self.vm_hooks_ptr, result_handle) } - fn managed_get_prev_block_random_seed(&self, result_handle: i32) { + fn managed_get_prev_block_random_seed(&mut self, result_handle: i32) { (self.c_func_pointers_ptr.managed_get_prev_block_random_seed_func_ptr)(self.vm_hooks_ptr, result_handle) } - fn managed_get_return_data(&self, result_id: i32, result_handle: i32) { + fn managed_get_return_data(&mut self, result_id: i32, result_handle: i32) { (self.c_func_pointers_ptr.managed_get_return_data_func_ptr)(self.vm_hooks_ptr, result_id, result_handle) } - fn managed_get_multi_esdt_call_value(&self, multi_call_value_handle: i32) { + fn managed_get_multi_esdt_call_value(&mut self, multi_call_value_handle: i32) { (self.c_func_pointers_ptr.managed_get_multi_esdt_call_value_func_ptr)(self.vm_hooks_ptr, multi_call_value_handle) } - fn managed_get_back_transfers(&self, esdt_transfers_value_handle: i32, egld_value_handle: i32) { + fn managed_get_back_transfers(&mut self, esdt_transfers_value_handle: i32, egld_value_handle: i32) { (self.c_func_pointers_ptr.managed_get_back_transfers_func_ptr)(self.vm_hooks_ptr, esdt_transfers_value_handle, egld_value_handle) } - fn managed_get_esdt_balance(&self, address_handle: i32, token_id_handle: i32, nonce: i64, value_handle: i32) { + fn managed_get_esdt_balance(&mut self, address_handle: i32, token_id_handle: i32, nonce: i64, value_handle: i32) { (self.c_func_pointers_ptr.managed_get_esdt_balance_func_ptr)(self.vm_hooks_ptr, address_handle, token_id_handle, nonce, value_handle) } - fn managed_get_esdt_token_data(&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) { + 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) { (self.c_func_pointers_ptr.managed_get_esdt_token_data_func_ptr)(self.vm_hooks_ptr, address_handle, token_id_handle, nonce, value_handle, properties_handle, hash_handle, name_handle, attributes_handle, creator_handle, royalties_handle, uris_handle) } - fn managed_async_call(&self, dest_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32) { + fn managed_async_call(&mut self, dest_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32) { (self.c_func_pointers_ptr.managed_async_call_func_ptr)(self.vm_hooks_ptr, dest_handle, value_handle, function_handle, arguments_handle) } - fn managed_create_async_call(&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) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.managed_create_async_call_func_ptr)(self.vm_hooks_ptr, dest_handle, value_handle, function_handle, arguments_handle, self.convert_mem_ptr(success_offset), self.convert_mem_length(success_length), self.convert_mem_ptr(error_offset), self.convert_mem_length(error_length), gas, extra_gas_for_callback, callback_closure_handle) } - fn managed_get_callback_closure(&self, callback_closure_handle: i32) { + fn managed_get_callback_closure(&mut self, callback_closure_handle: i32) { (self.c_func_pointers_ptr.managed_get_callback_closure_func_ptr)(self.vm_hooks_ptr, callback_closure_handle) } - fn managed_upgrade_from_source_contract(&self, dest_handle: i32, gas: i64, value_handle: i32, address_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_handle: i32) { + 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) { (self.c_func_pointers_ptr.managed_upgrade_from_source_contract_func_ptr)(self.vm_hooks_ptr, dest_handle, gas, value_handle, address_handle, code_metadata_handle, arguments_handle, result_handle) } - fn managed_upgrade_contract(&self, dest_handle: i32, gas: i64, value_handle: i32, code_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_handle: i32) { + 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) { (self.c_func_pointers_ptr.managed_upgrade_contract_func_ptr)(self.vm_hooks_ptr, dest_handle, gas, value_handle, code_handle, code_metadata_handle, arguments_handle, result_handle) } - fn managed_delete_contract(&self, dest_handle: i32, gas_limit: i64, arguments_handle: i32) { + fn managed_delete_contract(&mut self, dest_handle: i32, gas_limit: i64, arguments_handle: i32) { (self.c_func_pointers_ptr.managed_delete_contract_func_ptr)(self.vm_hooks_ptr, dest_handle, gas_limit, arguments_handle) } - fn managed_deploy_from_source_contract(&self, gas: i64, value_handle: i32, address_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_address_handle: i32, result_handle: i32) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.managed_deploy_from_source_contract_func_ptr)(self.vm_hooks_ptr, gas, value_handle, address_handle, code_metadata_handle, arguments_handle, result_address_handle, result_handle) } - fn managed_create_contract(&self, gas: i64, value_handle: i32, code_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_address_handle: i32, result_handle: i32) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.managed_create_contract_func_ptr)(self.vm_hooks_ptr, gas, value_handle, code_handle, code_metadata_handle, arguments_handle, result_address_handle, result_handle) } - fn managed_execute_read_only(&self, gas: i64, address_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32 { + fn managed_execute_read_only(&mut self, gas: i64, address_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_execute_read_only_func_ptr)(self.vm_hooks_ptr, gas, address_handle, function_handle, arguments_handle, result_handle) } - fn managed_execute_on_same_context(&self, gas: i64, address_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.managed_execute_on_same_context_func_ptr)(self.vm_hooks_ptr, gas, address_handle, value_handle, function_handle, arguments_handle, result_handle) } - fn managed_execute_on_dest_context(&self, gas: i64, address_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.managed_execute_on_dest_context_func_ptr)(self.vm_hooks_ptr, gas, address_handle, value_handle, function_handle, arguments_handle, result_handle) } - fn managed_multi_transfer_esdt_nft_execute(&self, dst_handle: i32, token_transfers_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.managed_multi_transfer_esdt_nft_execute_func_ptr)(self.vm_hooks_ptr, dst_handle, token_transfers_handle, gas_limit, function_handle, arguments_handle) } - fn managed_multi_transfer_esdt_nft_execute_by_user(&self, user_handle: i32, dst_handle: i32, token_transfers_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.managed_multi_transfer_esdt_nft_execute_by_user_func_ptr)(self.vm_hooks_ptr, user_handle, dst_handle, token_transfers_handle, gas_limit, function_handle, arguments_handle) } - fn managed_transfer_value_execute(&self, dst_handle: i32, value_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32 { + fn managed_transfer_value_execute(&mut self, dst_handle: i32, value_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_transfer_value_execute_func_ptr)(self.vm_hooks_ptr, dst_handle, value_handle, gas_limit, function_handle, arguments_handle) } - fn managed_is_esdt_frozen(&self, address_handle: i32, token_id_handle: i32, nonce: i64) -> i32 { + fn managed_is_esdt_frozen(&mut self, address_handle: i32, token_id_handle: i32, nonce: i64) -> i32 { (self.c_func_pointers_ptr.managed_is_esdt_frozen_func_ptr)(self.vm_hooks_ptr, address_handle, token_id_handle, nonce) } - fn managed_is_esdt_limited_transfer(&self, token_id_handle: i32) -> i32 { + fn managed_is_esdt_limited_transfer(&mut self, token_id_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_is_esdt_limited_transfer_func_ptr)(self.vm_hooks_ptr, token_id_handle) } - fn managed_is_esdt_paused(&self, token_id_handle: i32) -> i32 { + fn managed_is_esdt_paused(&mut self, token_id_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_is_esdt_paused_func_ptr)(self.vm_hooks_ptr, token_id_handle) } - fn managed_buffer_to_hex(&self, source_handle: i32, dest_handle: i32) { + fn managed_buffer_to_hex(&mut self, source_handle: i32, dest_handle: i32) { (self.c_func_pointers_ptr.managed_buffer_to_hex_func_ptr)(self.vm_hooks_ptr, source_handle, dest_handle) } - fn managed_get_code_metadata(&self, address_handle: i32, response_handle: i32) { + fn managed_get_code_metadata(&mut self, address_handle: i32, response_handle: i32) { (self.c_func_pointers_ptr.managed_get_code_metadata_func_ptr)(self.vm_hooks_ptr, address_handle, response_handle) } - fn managed_is_builtin_function(&self, function_name_handle: i32) -> i32 { + fn managed_is_builtin_function(&mut self, function_name_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_is_builtin_function_func_ptr)(self.vm_hooks_ptr, function_name_handle) } - fn big_float_new_from_parts(&self, integral_part: i32, fractional_part: i32, exponent: i32) -> i32 { + fn big_float_new_from_parts(&mut self, integral_part: i32, fractional_part: i32, exponent: i32) -> i32 { (self.c_func_pointers_ptr.big_float_new_from_parts_func_ptr)(self.vm_hooks_ptr, integral_part, fractional_part, exponent) } - fn big_float_new_from_frac(&self, numerator: i64, denominator: i64) -> i32 { + fn big_float_new_from_frac(&mut self, numerator: i64, denominator: i64) -> i32 { (self.c_func_pointers_ptr.big_float_new_from_frac_func_ptr)(self.vm_hooks_ptr, numerator, denominator) } - fn big_float_new_from_sci(&self, significand: i64, exponent: i64) -> i32 { + fn big_float_new_from_sci(&mut self, significand: i64, exponent: i64) -> i32 { (self.c_func_pointers_ptr.big_float_new_from_sci_func_ptr)(self.vm_hooks_ptr, significand, exponent) } - fn big_float_add(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_float_add(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_float_add_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_float_sub(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_float_sub(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_float_sub_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_float_mul(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_float_mul(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_float_mul_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_float_div(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_float_div(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_float_div_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_float_neg(&self, destination_handle: i32, op_handle: i32) { + fn big_float_neg(&mut self, destination_handle: i32, op_handle: i32) { (self.c_func_pointers_ptr.big_float_neg_func_ptr)(self.vm_hooks_ptr, destination_handle, op_handle) } - fn big_float_clone(&self, destination_handle: i32, op_handle: i32) { + fn big_float_clone(&mut self, destination_handle: i32, op_handle: i32) { (self.c_func_pointers_ptr.big_float_clone_func_ptr)(self.vm_hooks_ptr, destination_handle, op_handle) } - fn big_float_cmp(&self, op1_handle: i32, op2_handle: i32) -> i32 { + fn big_float_cmp(&mut self, op1_handle: i32, op2_handle: i32) -> i32 { (self.c_func_pointers_ptr.big_float_cmp_func_ptr)(self.vm_hooks_ptr, op1_handle, op2_handle) } - fn big_float_abs(&self, destination_handle: i32, op_handle: i32) { + fn big_float_abs(&mut self, destination_handle: i32, op_handle: i32) { (self.c_func_pointers_ptr.big_float_abs_func_ptr)(self.vm_hooks_ptr, destination_handle, op_handle) } - fn big_float_sign(&self, op_handle: i32) -> i32 { + fn big_float_sign(&mut self, op_handle: i32) -> i32 { (self.c_func_pointers_ptr.big_float_sign_func_ptr)(self.vm_hooks_ptr, op_handle) } - fn big_float_sqrt(&self, destination_handle: i32, op_handle: i32) { + fn big_float_sqrt(&mut self, destination_handle: i32, op_handle: i32) { (self.c_func_pointers_ptr.big_float_sqrt_func_ptr)(self.vm_hooks_ptr, destination_handle, op_handle) } - fn big_float_pow(&self, destination_handle: i32, op_handle: i32, exponent: i32) { + fn big_float_pow(&mut self, destination_handle: i32, op_handle: i32, exponent: i32) { (self.c_func_pointers_ptr.big_float_pow_func_ptr)(self.vm_hooks_ptr, destination_handle, op_handle, exponent) } - fn big_float_floor(&self, dest_big_int_handle: i32, op_handle: i32) { + fn big_float_floor(&mut self, dest_big_int_handle: i32, op_handle: i32) { (self.c_func_pointers_ptr.big_float_floor_func_ptr)(self.vm_hooks_ptr, dest_big_int_handle, op_handle) } - fn big_float_ceil(&self, dest_big_int_handle: i32, op_handle: i32) { + fn big_float_ceil(&mut self, dest_big_int_handle: i32, op_handle: i32) { (self.c_func_pointers_ptr.big_float_ceil_func_ptr)(self.vm_hooks_ptr, dest_big_int_handle, op_handle) } - fn big_float_truncate(&self, dest_big_int_handle: i32, op_handle: i32) { + fn big_float_truncate(&mut self, dest_big_int_handle: i32, op_handle: i32) { (self.c_func_pointers_ptr.big_float_truncate_func_ptr)(self.vm_hooks_ptr, dest_big_int_handle, op_handle) } - fn big_float_set_int64(&self, destination_handle: i32, value: i64) { + fn big_float_set_int64(&mut self, destination_handle: i32, value: i64) { (self.c_func_pointers_ptr.big_float_set_int64_func_ptr)(self.vm_hooks_ptr, destination_handle, value) } - fn big_float_is_int(&self, op_handle: i32) -> i32 { + fn big_float_is_int(&mut self, op_handle: i32) -> i32 { (self.c_func_pointers_ptr.big_float_is_int_func_ptr)(self.vm_hooks_ptr, op_handle) } - fn big_float_set_big_int(&self, destination_handle: i32, big_int_handle: i32) { + fn big_float_set_big_int(&mut self, destination_handle: i32, big_int_handle: i32) { (self.c_func_pointers_ptr.big_float_set_big_int_func_ptr)(self.vm_hooks_ptr, destination_handle, big_int_handle) } - fn big_float_get_const_pi(&self, destination_handle: i32) { + fn big_float_get_const_pi(&mut self, destination_handle: i32) { (self.c_func_pointers_ptr.big_float_get_const_pi_func_ptr)(self.vm_hooks_ptr, destination_handle) } - fn big_float_get_const_e(&self, destination_handle: i32) { + fn big_float_get_const_e(&mut self, destination_handle: i32) { (self.c_func_pointers_ptr.big_float_get_const_e_func_ptr)(self.vm_hooks_ptr, destination_handle) } - fn big_int_get_unsigned_argument(&self, id: i32, destination_handle: i32) { + fn big_int_get_unsigned_argument(&mut self, id: i32, destination_handle: i32) { (self.c_func_pointers_ptr.big_int_get_unsigned_argument_func_ptr)(self.vm_hooks_ptr, id, destination_handle) } - fn big_int_get_signed_argument(&self, id: i32, destination_handle: i32) { + fn big_int_get_signed_argument(&mut self, id: i32, destination_handle: i32) { (self.c_func_pointers_ptr.big_int_get_signed_argument_func_ptr)(self.vm_hooks_ptr, id, destination_handle) } - fn big_int_storage_store_unsigned(&self, key_offset: MemPtr, key_length: MemLength, source_handle: i32) -> i32 { + fn big_int_storage_store_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, source_handle: i32) -> i32 { (self.c_func_pointers_ptr.big_int_storage_store_unsigned_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length), source_handle) } - fn big_int_storage_load_unsigned(&self, key_offset: MemPtr, key_length: MemLength, destination_handle: i32) -> i32 { + fn big_int_storage_load_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, destination_handle: i32) -> i32 { (self.c_func_pointers_ptr.big_int_storage_load_unsigned_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length), destination_handle) } - fn big_int_get_call_value(&self, destination_handle: i32) { + fn big_int_get_call_value(&mut self, destination_handle: i32) { (self.c_func_pointers_ptr.big_int_get_call_value_func_ptr)(self.vm_hooks_ptr, destination_handle) } - fn big_int_get_esdt_call_value(&self, destination: i32) { + fn big_int_get_esdt_call_value(&mut self, destination: i32) { (self.c_func_pointers_ptr.big_int_get_esdt_call_value_func_ptr)(self.vm_hooks_ptr, destination) } - fn big_int_get_esdt_call_value_by_index(&self, destination_handle: i32, index: i32) { + fn big_int_get_esdt_call_value_by_index(&mut self, destination_handle: i32, index: i32) { (self.c_func_pointers_ptr.big_int_get_esdt_call_value_by_index_func_ptr)(self.vm_hooks_ptr, destination_handle, index) } - fn big_int_get_external_balance(&self, address_offset: MemPtr, result: i32) { + fn big_int_get_external_balance(&mut self, address_offset: MemPtr, result: i32) { (self.c_func_pointers_ptr.big_int_get_external_balance_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(address_offset), result) } - fn big_int_get_esdt_external_balance(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, result_handle: i32) { + 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) { (self.c_func_pointers_ptr.big_int_get_esdt_external_balance_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(address_offset), self.convert_mem_ptr(token_id_offset), self.convert_mem_length(token_id_len), nonce, result_handle) } - fn big_int_new(&self, small_value: i64) -> i32 { + fn big_int_new(&mut self, small_value: i64) -> i32 { (self.c_func_pointers_ptr.big_int_new_func_ptr)(self.vm_hooks_ptr, small_value) } - fn big_int_unsigned_byte_length(&self, reference_handle: i32) -> i32 { + fn big_int_unsigned_byte_length(&mut self, reference_handle: i32) -> i32 { (self.c_func_pointers_ptr.big_int_unsigned_byte_length_func_ptr)(self.vm_hooks_ptr, reference_handle) } - fn big_int_signed_byte_length(&self, reference_handle: i32) -> i32 { + fn big_int_signed_byte_length(&mut self, reference_handle: i32) -> i32 { (self.c_func_pointers_ptr.big_int_signed_byte_length_func_ptr)(self.vm_hooks_ptr, reference_handle) } - fn big_int_get_unsigned_bytes(&self, reference_handle: i32, byte_offset: MemPtr) -> i32 { + fn big_int_get_unsigned_bytes(&mut self, reference_handle: i32, byte_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.big_int_get_unsigned_bytes_func_ptr)(self.vm_hooks_ptr, reference_handle, self.convert_mem_ptr(byte_offset)) } - fn big_int_get_signed_bytes(&self, reference_handle: i32, byte_offset: MemPtr) -> i32 { + fn big_int_get_signed_bytes(&mut self, reference_handle: i32, byte_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.big_int_get_signed_bytes_func_ptr)(self.vm_hooks_ptr, reference_handle, self.convert_mem_ptr(byte_offset)) } - fn big_int_set_unsigned_bytes(&self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength) { + fn big_int_set_unsigned_bytes(&mut self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength) { (self.c_func_pointers_ptr.big_int_set_unsigned_bytes_func_ptr)(self.vm_hooks_ptr, destination_handle, self.convert_mem_ptr(byte_offset), self.convert_mem_length(byte_length)) } - fn big_int_set_signed_bytes(&self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength) { + fn big_int_set_signed_bytes(&mut self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength) { (self.c_func_pointers_ptr.big_int_set_signed_bytes_func_ptr)(self.vm_hooks_ptr, destination_handle, self.convert_mem_ptr(byte_offset), self.convert_mem_length(byte_length)) } - fn big_int_is_int64(&self, destination_handle: i32) -> i32 { + fn big_int_is_int64(&mut self, destination_handle: i32) -> i32 { (self.c_func_pointers_ptr.big_int_is_int64_func_ptr)(self.vm_hooks_ptr, destination_handle) } - fn big_int_get_int64(&self, destination_handle: i32) -> i64 { + fn big_int_get_int64(&mut self, destination_handle: i32) -> i64 { (self.c_func_pointers_ptr.big_int_get_int64_func_ptr)(self.vm_hooks_ptr, destination_handle) } - fn big_int_set_int64(&self, destination_handle: i32, value: i64) { + fn big_int_set_int64(&mut self, destination_handle: i32, value: i64) { (self.c_func_pointers_ptr.big_int_set_int64_func_ptr)(self.vm_hooks_ptr, destination_handle, value) } - fn big_int_add(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_add(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_int_add_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_int_sub(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_sub(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_int_sub_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_int_mul(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_mul(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_int_mul_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_int_tdiv(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_tdiv(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_int_tdiv_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_int_tmod(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_tmod(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_int_tmod_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_int_ediv(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_ediv(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_int_ediv_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_int_emod(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_emod(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_int_emod_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_int_sqrt(&self, destination_handle: i32, op_handle: i32) { + fn big_int_sqrt(&mut self, destination_handle: i32, op_handle: i32) { (self.c_func_pointers_ptr.big_int_sqrt_func_ptr)(self.vm_hooks_ptr, destination_handle, op_handle) } - fn big_int_pow(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_pow(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_int_pow_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_int_log2(&self, op1_handle: i32) -> i32 { + fn big_int_log2(&mut self, op1_handle: i32) -> i32 { (self.c_func_pointers_ptr.big_int_log2_func_ptr)(self.vm_hooks_ptr, op1_handle) } - fn big_int_abs(&self, destination_handle: i32, op_handle: i32) { + fn big_int_abs(&mut self, destination_handle: i32, op_handle: i32) { (self.c_func_pointers_ptr.big_int_abs_func_ptr)(self.vm_hooks_ptr, destination_handle, op_handle) } - fn big_int_neg(&self, destination_handle: i32, op_handle: i32) { + fn big_int_neg(&mut self, destination_handle: i32, op_handle: i32) { (self.c_func_pointers_ptr.big_int_neg_func_ptr)(self.vm_hooks_ptr, destination_handle, op_handle) } - fn big_int_sign(&self, op_handle: i32) -> i32 { + fn big_int_sign(&mut self, op_handle: i32) -> i32 { (self.c_func_pointers_ptr.big_int_sign_func_ptr)(self.vm_hooks_ptr, op_handle) } - fn big_int_cmp(&self, op1_handle: i32, op2_handle: i32) -> i32 { + fn big_int_cmp(&mut self, op1_handle: i32, op2_handle: i32) -> i32 { (self.c_func_pointers_ptr.big_int_cmp_func_ptr)(self.vm_hooks_ptr, op1_handle, op2_handle) } - fn big_int_not(&self, destination_handle: i32, op_handle: i32) { + fn big_int_not(&mut self, destination_handle: i32, op_handle: i32) { (self.c_func_pointers_ptr.big_int_not_func_ptr)(self.vm_hooks_ptr, destination_handle, op_handle) } - fn big_int_and(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_and(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_int_and_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_int_or(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_or(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_int_or_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_int_xor(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_xor(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { (self.c_func_pointers_ptr.big_int_xor_func_ptr)(self.vm_hooks_ptr, destination_handle, op1_handle, op2_handle) } - fn big_int_shr(&self, destination_handle: i32, op_handle: i32, bits: i32) { + fn big_int_shr(&mut self, destination_handle: i32, op_handle: i32, bits: i32) { (self.c_func_pointers_ptr.big_int_shr_func_ptr)(self.vm_hooks_ptr, destination_handle, op_handle, bits) } - fn big_int_shl(&self, destination_handle: i32, op_handle: i32, bits: i32) { + fn big_int_shl(&mut self, destination_handle: i32, op_handle: i32, bits: i32) { (self.c_func_pointers_ptr.big_int_shl_func_ptr)(self.vm_hooks_ptr, destination_handle, op_handle, bits) } - fn big_int_finish_unsigned(&self, reference_handle: i32) { + fn big_int_finish_unsigned(&mut self, reference_handle: i32) { (self.c_func_pointers_ptr.big_int_finish_unsigned_func_ptr)(self.vm_hooks_ptr, reference_handle) } - fn big_int_finish_signed(&self, reference_handle: i32) { + fn big_int_finish_signed(&mut self, reference_handle: i32) { (self.c_func_pointers_ptr.big_int_finish_signed_func_ptr)(self.vm_hooks_ptr, reference_handle) } - fn big_int_to_string(&self, big_int_handle: i32, destination_handle: i32) { + fn big_int_to_string(&mut self, big_int_handle: i32, destination_handle: i32) { (self.c_func_pointers_ptr.big_int_to_string_func_ptr)(self.vm_hooks_ptr, big_int_handle, destination_handle) } - fn mbuffer_new(&self) -> i32 { + fn mbuffer_new(&mut self) -> i32 { (self.c_func_pointers_ptr.mbuffer_new_func_ptr)(self.vm_hooks_ptr) } - fn mbuffer_new_from_bytes(&self, data_offset: MemPtr, data_length: MemLength) -> i32 { + fn mbuffer_new_from_bytes(&mut self, data_offset: MemPtr, data_length: MemLength) -> i32 { (self.c_func_pointers_ptr.mbuffer_new_from_bytes_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(data_offset), self.convert_mem_length(data_length)) } - fn mbuffer_get_length(&self, m_buffer_handle: i32) -> i32 { + fn mbuffer_get_length(&mut self, m_buffer_handle: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_get_length_func_ptr)(self.vm_hooks_ptr, m_buffer_handle) } - fn mbuffer_get_bytes(&self, m_buffer_handle: i32, result_offset: MemPtr) -> i32 { + fn mbuffer_get_bytes(&mut self, m_buffer_handle: i32, result_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.mbuffer_get_bytes_func_ptr)(self.vm_hooks_ptr, m_buffer_handle, self.convert_mem_ptr(result_offset)) } - fn mbuffer_get_byte_slice(&self, source_handle: i32, starting_position: i32, slice_length: i32, result_offset: MemPtr) -> i32 { + fn mbuffer_get_byte_slice(&mut self, source_handle: i32, starting_position: i32, slice_length: i32, result_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.mbuffer_get_byte_slice_func_ptr)(self.vm_hooks_ptr, source_handle, starting_position, slice_length, self.convert_mem_ptr(result_offset)) } - fn mbuffer_copy_byte_slice(&self, source_handle: i32, starting_position: i32, slice_length: i32, destination_handle: i32) -> i32 { + fn mbuffer_copy_byte_slice(&mut self, source_handle: i32, starting_position: i32, slice_length: i32, destination_handle: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_copy_byte_slice_func_ptr)(self.vm_hooks_ptr, source_handle, starting_position, slice_length, destination_handle) } - fn mbuffer_eq(&self, m_buffer_handle1: i32, m_buffer_handle2: i32) -> i32 { + fn mbuffer_eq(&mut self, m_buffer_handle1: i32, m_buffer_handle2: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_eq_func_ptr)(self.vm_hooks_ptr, m_buffer_handle1, m_buffer_handle2) } - fn mbuffer_set_bytes(&self, m_buffer_handle: i32, data_offset: MemPtr, data_length: MemLength) -> i32 { + fn mbuffer_set_bytes(&mut self, m_buffer_handle: i32, data_offset: MemPtr, data_length: MemLength) -> i32 { (self.c_func_pointers_ptr.mbuffer_set_bytes_func_ptr)(self.vm_hooks_ptr, m_buffer_handle, self.convert_mem_ptr(data_offset), self.convert_mem_length(data_length)) } - fn mbuffer_set_byte_slice(&self, m_buffer_handle: i32, starting_position: i32, data_length: MemLength, data_offset: MemPtr) -> i32 { + fn mbuffer_set_byte_slice(&mut self, m_buffer_handle: i32, starting_position: i32, data_length: MemLength, data_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.mbuffer_set_byte_slice_func_ptr)(self.vm_hooks_ptr, m_buffer_handle, starting_position, self.convert_mem_length(data_length), self.convert_mem_ptr(data_offset)) } - fn mbuffer_append(&self, accumulator_handle: i32, data_handle: i32) -> i32 { + fn mbuffer_append(&mut self, accumulator_handle: i32, data_handle: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_append_func_ptr)(self.vm_hooks_ptr, accumulator_handle, data_handle) } - fn mbuffer_append_bytes(&self, accumulator_handle: i32, data_offset: MemPtr, data_length: MemLength) -> i32 { + fn mbuffer_append_bytes(&mut self, accumulator_handle: i32, data_offset: MemPtr, data_length: MemLength) -> i32 { (self.c_func_pointers_ptr.mbuffer_append_bytes_func_ptr)(self.vm_hooks_ptr, accumulator_handle, self.convert_mem_ptr(data_offset), self.convert_mem_length(data_length)) } - fn mbuffer_to_big_int_unsigned(&self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { + fn mbuffer_to_big_int_unsigned(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_to_big_int_unsigned_func_ptr)(self.vm_hooks_ptr, m_buffer_handle, big_int_handle) } - fn mbuffer_to_big_int_signed(&self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { + fn mbuffer_to_big_int_signed(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_to_big_int_signed_func_ptr)(self.vm_hooks_ptr, m_buffer_handle, big_int_handle) } - fn mbuffer_from_big_int_unsigned(&self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { + fn mbuffer_from_big_int_unsigned(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_from_big_int_unsigned_func_ptr)(self.vm_hooks_ptr, m_buffer_handle, big_int_handle) } - fn mbuffer_from_big_int_signed(&self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { + fn mbuffer_from_big_int_signed(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_from_big_int_signed_func_ptr)(self.vm_hooks_ptr, m_buffer_handle, big_int_handle) } - fn mbuffer_to_big_float(&self, m_buffer_handle: i32, big_float_handle: i32) -> i32 { + fn mbuffer_to_big_float(&mut self, m_buffer_handle: i32, big_float_handle: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_to_big_float_func_ptr)(self.vm_hooks_ptr, m_buffer_handle, big_float_handle) } - fn mbuffer_from_big_float(&self, m_buffer_handle: i32, big_float_handle: i32) -> i32 { + fn mbuffer_from_big_float(&mut self, m_buffer_handle: i32, big_float_handle: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_from_big_float_func_ptr)(self.vm_hooks_ptr, m_buffer_handle, big_float_handle) } - fn mbuffer_storage_store(&self, key_handle: i32, source_handle: i32) -> i32 { + fn mbuffer_storage_store(&mut self, key_handle: i32, source_handle: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_storage_store_func_ptr)(self.vm_hooks_ptr, key_handle, source_handle) } - fn mbuffer_storage_load(&self, key_handle: i32, destination_handle: i32) -> i32 { + fn mbuffer_storage_load(&mut self, key_handle: i32, destination_handle: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_storage_load_func_ptr)(self.vm_hooks_ptr, key_handle, destination_handle) } - fn mbuffer_storage_load_from_address(&self, address_handle: i32, key_handle: i32, destination_handle: i32) { + fn mbuffer_storage_load_from_address(&mut self, address_handle: i32, key_handle: i32, destination_handle: i32) { (self.c_func_pointers_ptr.mbuffer_storage_load_from_address_func_ptr)(self.vm_hooks_ptr, address_handle, key_handle, destination_handle) } - fn mbuffer_get_argument(&self, id: i32, destination_handle: i32) -> i32 { + fn mbuffer_get_argument(&mut self, id: i32, destination_handle: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_get_argument_func_ptr)(self.vm_hooks_ptr, id, destination_handle) } - fn mbuffer_finish(&self, source_handle: i32) -> i32 { + fn mbuffer_finish(&mut self, source_handle: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_finish_func_ptr)(self.vm_hooks_ptr, source_handle) } - fn mbuffer_set_random(&self, destination_handle: i32, length: i32) -> i32 { + fn mbuffer_set_random(&mut self, destination_handle: i32, length: i32) -> i32 { (self.c_func_pointers_ptr.mbuffer_set_random_func_ptr)(self.vm_hooks_ptr, destination_handle, length) } - fn managed_map_new(&self) -> i32 { + fn managed_map_new(&mut self) -> i32 { (self.c_func_pointers_ptr.managed_map_new_func_ptr)(self.vm_hooks_ptr) } - fn managed_map_put(&self, m_map_handle: i32, key_handle: i32, value_handle: i32) -> i32 { + fn managed_map_put(&mut self, m_map_handle: i32, key_handle: i32, value_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_map_put_func_ptr)(self.vm_hooks_ptr, m_map_handle, key_handle, value_handle) } - fn managed_map_get(&self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> i32 { + fn managed_map_get(&mut self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_map_get_func_ptr)(self.vm_hooks_ptr, m_map_handle, key_handle, out_value_handle) } - fn managed_map_remove(&self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> i32 { + fn managed_map_remove(&mut self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_map_remove_func_ptr)(self.vm_hooks_ptr, m_map_handle, key_handle, out_value_handle) } - fn managed_map_contains(&self, m_map_handle: i32, key_handle: i32) -> i32 { + fn managed_map_contains(&mut self, m_map_handle: i32, key_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_map_contains_func_ptr)(self.vm_hooks_ptr, m_map_handle, key_handle) } - fn small_int_get_unsigned_argument(&self, id: i32) -> i64 { + fn small_int_get_unsigned_argument(&mut self, id: i32) -> i64 { (self.c_func_pointers_ptr.small_int_get_unsigned_argument_func_ptr)(self.vm_hooks_ptr, id) } - fn small_int_get_signed_argument(&self, id: i32) -> i64 { + fn small_int_get_signed_argument(&mut self, id: i32) -> i64 { (self.c_func_pointers_ptr.small_int_get_signed_argument_func_ptr)(self.vm_hooks_ptr, id) } - fn small_int_finish_unsigned(&self, value: i64) { + fn small_int_finish_unsigned(&mut self, value: i64) { (self.c_func_pointers_ptr.small_int_finish_unsigned_func_ptr)(self.vm_hooks_ptr, value) } - fn small_int_finish_signed(&self, value: i64) { + fn small_int_finish_signed(&mut self, value: i64) { (self.c_func_pointers_ptr.small_int_finish_signed_func_ptr)(self.vm_hooks_ptr, value) } - fn small_int_storage_store_unsigned(&self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32 { + fn small_int_storage_store_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32 { (self.c_func_pointers_ptr.small_int_storage_store_unsigned_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length), value) } - fn small_int_storage_store_signed(&self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32 { + fn small_int_storage_store_signed(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32 { (self.c_func_pointers_ptr.small_int_storage_store_signed_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length), value) } - fn small_int_storage_load_unsigned(&self, key_offset: MemPtr, key_length: MemLength) -> i64 { + fn small_int_storage_load_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength) -> i64 { (self.c_func_pointers_ptr.small_int_storage_load_unsigned_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length)) } - fn small_int_storage_load_signed(&self, key_offset: MemPtr, key_length: MemLength) -> i64 { + fn small_int_storage_load_signed(&mut self, key_offset: MemPtr, key_length: MemLength) -> i64 { (self.c_func_pointers_ptr.small_int_storage_load_signed_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length)) } - fn int64get_argument(&self, id: i32) -> i64 { + fn int64get_argument(&mut self, id: i32) -> i64 { (self.c_func_pointers_ptr.int64get_argument_func_ptr)(self.vm_hooks_ptr, id) } - fn int64finish(&self, value: i64) { + fn int64finish(&mut self, value: i64) { (self.c_func_pointers_ptr.int64finish_func_ptr)(self.vm_hooks_ptr, value) } - fn int64storage_store(&self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32 { + fn int64storage_store(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32 { (self.c_func_pointers_ptr.int64storage_store_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length), value) } - fn int64storage_load(&self, key_offset: MemPtr, key_length: MemLength) -> i64 { + fn int64storage_load(&mut self, key_offset: MemPtr, key_length: MemLength) -> i64 { (self.c_func_pointers_ptr.int64storage_load_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length)) } - fn sha256(&self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32 { + fn sha256(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.sha256_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(data_offset), self.convert_mem_length(length), self.convert_mem_ptr(result_offset)) } - fn managed_sha256(&self, input_handle: i32, output_handle: i32) -> i32 { + fn managed_sha256(&mut self, input_handle: i32, output_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_sha256_func_ptr)(self.vm_hooks_ptr, input_handle, output_handle) } - fn keccak256(&self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32 { + fn keccak256(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.keccak256_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(data_offset), self.convert_mem_length(length), self.convert_mem_ptr(result_offset)) } - fn managed_keccak256(&self, input_handle: i32, output_handle: i32) -> i32 { + fn managed_keccak256(&mut self, input_handle: i32, output_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_keccak256_func_ptr)(self.vm_hooks_ptr, input_handle, output_handle) } - fn ripemd160(&self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32 { + fn ripemd160(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.ripemd160_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(data_offset), self.convert_mem_length(length), self.convert_mem_ptr(result_offset)) } - fn managed_ripemd160(&self, input_handle: i32, output_handle: i32) -> i32 { + fn managed_ripemd160(&mut self, input_handle: i32, output_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_ripemd160_func_ptr)(self.vm_hooks_ptr, input_handle, output_handle) } - fn verify_bls(&self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32 { + fn verify_bls(&mut self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.verify_bls_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_ptr(message_offset), self.convert_mem_length(message_length), self.convert_mem_ptr(sig_offset)) } - fn managed_verify_bls(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { + fn managed_verify_bls(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_verify_bls_func_ptr)(self.vm_hooks_ptr, key_handle, message_handle, sig_handle) } - fn verify_ed25519(&self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32 { + fn verify_ed25519(&mut self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.verify_ed25519_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_ptr(message_offset), self.convert_mem_length(message_length), self.convert_mem_ptr(sig_offset)) } - fn managed_verify_ed25519(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { + fn managed_verify_ed25519(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_verify_ed25519_func_ptr)(self.vm_hooks_ptr, key_handle, message_handle, sig_handle) } - fn verify_custom_secp256k1(&self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr, hash_type: i32) -> i32 { + fn verify_custom_secp256k1(&mut self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr, hash_type: i32) -> i32 { (self.c_func_pointers_ptr.verify_custom_secp256k1_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length), self.convert_mem_ptr(message_offset), self.convert_mem_length(message_length), self.convert_mem_ptr(sig_offset), hash_type) } - fn managed_verify_custom_secp256k1(&self, key_handle: i32, message_handle: i32, sig_handle: i32, hash_type: i32) -> i32 { + fn managed_verify_custom_secp256k1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32, hash_type: i32) -> i32 { (self.c_func_pointers_ptr.managed_verify_custom_secp256k1_func_ptr)(self.vm_hooks_ptr, key_handle, message_handle, sig_handle, hash_type) } - fn verify_secp256k1(&self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32 { + fn verify_secp256k1(&mut self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.verify_secp256k1_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(key_offset), self.convert_mem_length(key_length), self.convert_mem_ptr(message_offset), self.convert_mem_length(message_length), self.convert_mem_ptr(sig_offset)) } - fn managed_verify_secp256k1(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { + fn managed_verify_secp256k1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_verify_secp256k1_func_ptr)(self.vm_hooks_ptr, key_handle, message_handle, sig_handle) } - fn encode_secp256k1_der_signature(&self, r_offset: MemPtr, r_length: MemLength, s_offset: MemPtr, s_length: MemLength, sig_offset: MemPtr) -> i32 { + fn encode_secp256k1_der_signature(&mut self, r_offset: MemPtr, r_length: MemLength, s_offset: MemPtr, s_length: MemLength, sig_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.encode_secp256k1_der_signature_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(r_offset), self.convert_mem_length(r_length), self.convert_mem_ptr(s_offset), self.convert_mem_length(s_length), self.convert_mem_ptr(sig_offset)) } - fn managed_encode_secp256k1_der_signature(&self, r_handle: i32, s_handle: i32, sig_handle: i32) -> i32 { + fn managed_encode_secp256k1_der_signature(&mut self, r_handle: i32, s_handle: i32, sig_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_encode_secp256k1_der_signature_func_ptr)(self.vm_hooks_ptr, r_handle, s_handle, sig_handle) } - fn add_ec(&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) { + 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) { (self.c_func_pointers_ptr.add_ec_func_ptr)(self.vm_hooks_ptr, x_result_handle, y_result_handle, ec_handle, fst_point_xhandle, fst_point_yhandle, snd_point_xhandle, snd_point_yhandle) } - fn double_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) { + fn double_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) { (self.c_func_pointers_ptr.double_ec_func_ptr)(self.vm_hooks_ptr, x_result_handle, y_result_handle, ec_handle, point_xhandle, point_yhandle) } - fn is_on_curve_ec(&self, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) -> i32 { + fn is_on_curve_ec(&mut self, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) -> i32 { (self.c_func_pointers_ptr.is_on_curve_ec_func_ptr)(self.vm_hooks_ptr, ec_handle, point_xhandle, point_yhandle) } - fn scalar_base_mult_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32 { + fn scalar_base_mult_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32 { (self.c_func_pointers_ptr.scalar_base_mult_ec_func_ptr)(self.vm_hooks_ptr, x_result_handle, y_result_handle, ec_handle, self.convert_mem_ptr(data_offset), self.convert_mem_length(length)) } - fn managed_scalar_base_mult_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { + fn managed_scalar_base_mult_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_scalar_base_mult_ec_func_ptr)(self.vm_hooks_ptr, x_result_handle, y_result_handle, ec_handle, data_handle) } - fn scalar_mult_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32, data_offset: MemPtr, length: MemLength) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.scalar_mult_ec_func_ptr)(self.vm_hooks_ptr, x_result_handle, y_result_handle, ec_handle, point_xhandle, point_yhandle, self.convert_mem_ptr(data_offset), self.convert_mem_length(length)) } - fn managed_scalar_mult_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32, data_handle: i32) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.managed_scalar_mult_ec_func_ptr)(self.vm_hooks_ptr, x_result_handle, y_result_handle, ec_handle, point_xhandle, point_yhandle, data_handle) } - fn marshal_ec(&self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32 { + fn marshal_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.marshal_ec_func_ptr)(self.vm_hooks_ptr, x_pair_handle, y_pair_handle, ec_handle, self.convert_mem_ptr(result_offset)) } - fn managed_marshal_ec(&self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { + fn managed_marshal_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_marshal_ec_func_ptr)(self.vm_hooks_ptr, x_pair_handle, y_pair_handle, ec_handle, result_handle) } - fn marshal_compressed_ec(&self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32 { + fn marshal_compressed_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.marshal_compressed_ec_func_ptr)(self.vm_hooks_ptr, x_pair_handle, y_pair_handle, ec_handle, self.convert_mem_ptr(result_offset)) } - fn managed_marshal_compressed_ec(&self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { + fn managed_marshal_compressed_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_marshal_compressed_ec_func_ptr)(self.vm_hooks_ptr, x_pair_handle, y_pair_handle, ec_handle, result_handle) } - fn unmarshal_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32 { + fn unmarshal_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32 { (self.c_func_pointers_ptr.unmarshal_ec_func_ptr)(self.vm_hooks_ptr, x_result_handle, y_result_handle, ec_handle, self.convert_mem_ptr(data_offset), self.convert_mem_length(length)) } - fn managed_unmarshal_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { + fn managed_unmarshal_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_unmarshal_ec_func_ptr)(self.vm_hooks_ptr, x_result_handle, y_result_handle, ec_handle, data_handle) } - fn unmarshal_compressed_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32 { + fn unmarshal_compressed_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32 { (self.c_func_pointers_ptr.unmarshal_compressed_ec_func_ptr)(self.vm_hooks_ptr, x_result_handle, y_result_handle, ec_handle, self.convert_mem_ptr(data_offset), self.convert_mem_length(length)) } - fn managed_unmarshal_compressed_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { + fn managed_unmarshal_compressed_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_unmarshal_compressed_ec_func_ptr)(self.vm_hooks_ptr, x_result_handle, y_result_handle, ec_handle, data_handle) } - fn generate_key_ec(&self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32 { + fn generate_key_ec(&mut self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32 { (self.c_func_pointers_ptr.generate_key_ec_func_ptr)(self.vm_hooks_ptr, x_pub_key_handle, y_pub_key_handle, ec_handle, self.convert_mem_ptr(result_offset)) } - fn managed_generate_key_ec(&self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { + fn managed_generate_key_ec(&mut self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_generate_key_ec_func_ptr)(self.vm_hooks_ptr, x_pub_key_handle, y_pub_key_handle, ec_handle, result_handle) } - fn create_ec(&self, data_offset: MemPtr, data_length: MemLength) -> i32 { + fn create_ec(&mut self, data_offset: MemPtr, data_length: MemLength) -> i32 { (self.c_func_pointers_ptr.create_ec_func_ptr)(self.vm_hooks_ptr, self.convert_mem_ptr(data_offset), self.convert_mem_length(data_length)) } - fn managed_create_ec(&self, data_handle: i32) -> i32 { + fn managed_create_ec(&mut self, data_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_create_ec_func_ptr)(self.vm_hooks_ptr, data_handle) } - fn get_curve_length_ec(&self, ec_handle: i32) -> i32 { + fn get_curve_length_ec(&mut self, ec_handle: i32) -> i32 { (self.c_func_pointers_ptr.get_curve_length_ec_func_ptr)(self.vm_hooks_ptr, ec_handle) } - fn get_priv_key_byte_length_ec(&self, ec_handle: i32) -> i32 { + fn get_priv_key_byte_length_ec(&mut self, ec_handle: i32) -> i32 { (self.c_func_pointers_ptr.get_priv_key_byte_length_ec_func_ptr)(self.vm_hooks_ptr, ec_handle) } - fn elliptic_curve_get_values(&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) -> i32 { + 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) -> i32 { (self.c_func_pointers_ptr.elliptic_curve_get_values_func_ptr)(self.vm_hooks_ptr, ec_handle, field_order_handle, base_point_order_handle, eq_constant_handle, x_base_point_handle, y_base_point_handle) } - fn managed_verify_secp256r1(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { + fn managed_verify_secp256r1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_verify_secp256r1_func_ptr)(self.vm_hooks_ptr, key_handle, message_handle, sig_handle) } - fn managed_verify_blssignature_share(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { + fn managed_verify_blssignature_share(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_verify_blssignature_share_func_ptr)(self.vm_hooks_ptr, key_handle, message_handle, sig_handle) } - fn managed_verify_blsaggregated_signature(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { + fn managed_verify_blsaggregated_signature(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { (self.c_func_pointers_ptr.managed_verify_blsaggregated_signature_func_ptr)(self.vm_hooks_ptr, key_handle, message_handle, sig_handle) } } diff --git a/c-api/src/macros.rs b/c-api/src/macros.rs index a446678..aa850c1 100644 --- a/c-api/src/macros.rs +++ b/c-api/src/macros.rs @@ -46,4 +46,4 @@ macro_rules! cast_input_const_ptr { vm_exec_result_t::VM_EXEC_ERROR ) }; -} \ No newline at end of file +} diff --git a/meta/src/lib.rs b/meta/src/lib.rs index 74a536d..e9de724 100644 --- a/meta/src/lib.rs +++ b/meta/src/lib.rs @@ -20,5 +20,6 @@ pub fn capi_safe_unwind(attr: TokenStream, item: TokenStream) -> TokenStream { Err(_) => #fail_return, } } - }.into() -} \ No newline at end of file + } + .into() +} diff --git a/vm-executor-experimental/Cargo.toml b/vm-executor-experimental/Cargo.toml new file mode 100644 index 0000000..33bd6f5 --- /dev/null +++ b/vm-executor-experimental/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "multiversx-chain-vm-executor-wasmer-experimental" +version = "0.3.0" +edition = "2021" +publish = false # will also be published, but it is not yet ready for that + +[lib] + +[dependencies.multiversx-chain-vm-executor] +version = "0.3.0" +path = "../vm-executor" + +[dependencies] +wasmer = { version = "6.0", default-features = false, features = [ + "singlepass", + "sys", + "wat", +] } +wasmer-types = "6.0" + +chrono = "0.4.23" +log = "0.4.17" +loupe = "0.1.3" +rc-new-cyclic-fallible = "1.0.0" +anyhow = "1.0" diff --git a/vm-executor-experimental/src/lib.rs b/vm-executor-experimental/src/lib.rs new file mode 100644 index 0000000..bfc7433 --- /dev/null +++ b/vm-executor-experimental/src/lib.rs @@ -0,0 +1,14 @@ +#![allow(unused)] // TODO: temporary + +pub mod middlewares; +mod we_helpers; +mod we_imports; +mod we_instance; +mod we_instance_state; + +mod we_vm_hooks; +mod we_vm_hooks_builder; + +pub use we_instance::*; +pub use we_instance_state::*; +pub use we_vm_hooks_builder::*; diff --git a/vm-executor-experimental/src/middlewares.rs b/vm-executor-experimental/src/middlewares.rs new file mode 100644 index 0000000..428b6ff --- /dev/null +++ b/vm-executor-experimental/src/middlewares.rs @@ -0,0 +1,15 @@ +mod we_breakpoints; +mod we_metering; +mod we_metering_helpers; +mod we_opcode_control; +mod we_opcode_trace; +mod we_protected_globals; +mod we_protected_globals_trait; + +pub use we_breakpoints::*; +pub use we_metering::*; +pub use we_metering_helpers::*; +pub use we_opcode_control::OpcodeControl; +pub use we_opcode_trace::OpcodeTracer; +pub use we_protected_globals::ProtectedGlobals; +pub use we_protected_globals_trait::MiddlewareWithProtectedGlobals; diff --git a/vm-executor-experimental/src/middlewares/we_breakpoints.rs b/vm-executor-experimental/src/middlewares/we_breakpoints.rs new file mode 100644 index 0000000..28e4afd --- /dev/null +++ b/vm-executor-experimental/src/middlewares/we_breakpoints.rs @@ -0,0 +1,147 @@ +use std::sync::Mutex; + +use wasmer::sys::{FunctionMiddleware, MiddlewareReaderState, ModuleMiddleware}; +use wasmer::wasmparser::Operator; +use wasmer::{AsStoreMut, Instance, LocalFunctionIndex}; +use wasmer_types::{GlobalIndex, MiddlewareError, ModuleInfo}; + +use crate::we_helpers::{ + create_global_index, get_global_value_u64, is_control_flow_operator, set_global_value_u64, +}; + +const BREAKPOINT_VALUE: &str = "breakpoint_value"; + +pub(crate) const BREAKPOINT_VALUE_NO_BREAKPOINT: u64 = 0; +pub(crate) const BREAKPOINT_VALUE_OUT_OF_GAS: u64 = 4; +pub(crate) const BREAKPOINT_VALUE_MEMORY_LIMIT: u64 = 5; + +#[derive(Clone, Debug)] +struct BreakpointsGlobalIndex { + breakpoint_value_global_index: GlobalIndex, +} + +#[derive(Debug)] +pub(crate) struct Breakpoints { + global_index: Mutex>, +} + +impl Breakpoints { + pub(crate) fn new() -> Self { + Self { + global_index: Mutex::new(None), + } + } + + pub(crate) fn inject_breakpoint_condition( + &self, + state: &mut MiddlewareReaderState, + breakpoint_value: u64, + ) { + state.extend(&[ + Operator::If { + blockty: wasmer::wasmparser::BlockType::Empty, + }, + Operator::I64Const { + value: breakpoint_value as i64, + }, + Operator::GlobalSet { + global_index: self.get_breakpoint_value_global_index().as_u32(), + }, + Operator::End, + ]); + } + + pub fn get_breakpoint_value_global_index(&self) -> GlobalIndex { + self.global_index + .lock() + .unwrap() + .as_ref() + .unwrap() + .breakpoint_value_global_index + } +} + +unsafe impl Send for Breakpoints {} +unsafe impl Sync for Breakpoints {} + +impl ModuleMiddleware for Breakpoints { + fn generate_function_middleware( + &self, + _local_function_index: LocalFunctionIndex, + ) -> Box { + Box::new(FunctionBreakpoints { + global_index: self.global_index.lock().unwrap().clone().unwrap(), + }) + } + + fn transform_module_info(&self, module_info: &mut ModuleInfo) -> Result<(), MiddlewareError> { + let mut global_index = self.global_index.lock().unwrap(); + + *global_index = Some(BreakpointsGlobalIndex { + breakpoint_value_global_index: create_global_index( + module_info, + BREAKPOINT_VALUE, + BREAKPOINT_VALUE_NO_BREAKPOINT as i64, + ), + }); + + Ok(()) + } +} + +#[derive(Debug)] +struct FunctionBreakpoints { + global_index: BreakpointsGlobalIndex, +} + +impl FunctionBreakpoints { + fn inject_breakpoint_condition_check(&self, state: &mut MiddlewareReaderState) { + state.extend(&[ + Operator::GlobalGet { + global_index: self.global_index.breakpoint_value_global_index.as_u32(), + }, + Operator::I64Const { + value: BREAKPOINT_VALUE_NO_BREAKPOINT as i64, + }, + Operator::I64Ne, + Operator::If { + blockty: wasmer::wasmparser::BlockType::Empty, + }, + Operator::Unreachable, + Operator::End, + ]); + } +} + +impl FunctionMiddleware for FunctionBreakpoints { + fn feed<'b>( + &mut self, + operator: Operator<'b>, + state: &mut MiddlewareReaderState<'b>, + ) -> Result<(), MiddlewareError> { + let must_add_breakpoint = is_control_flow_operator(&operator); + + state.push_operator(operator); + + if must_add_breakpoint { + self.inject_breakpoint_condition_check(state) + } + + Ok(()) + } +} + +pub(crate) fn set_breakpoint_value( + instance: &Instance, + store: &mut impl AsStoreMut, + value: u64, +) -> anyhow::Result<()> { + set_global_value_u64(instance, store, BREAKPOINT_VALUE, value) +} + +pub(crate) fn get_breakpoint_value( + instance: &Instance, + store: &mut impl AsStoreMut, +) -> anyhow::Result { + get_global_value_u64(instance, store, BREAKPOINT_VALUE) +} diff --git a/vm-executor-experimental/src/middlewares/we_metering.rs b/vm-executor-experimental/src/middlewares/we_metering.rs new file mode 100644 index 0000000..b6e2f9d --- /dev/null +++ b/vm-executor-experimental/src/middlewares/we_metering.rs @@ -0,0 +1,235 @@ +// use crate::we_breakpoints::{Breakpoints, BREAKPOINT_VALUE_OUT_OF_GAS}; +use super::{ + get_local_cost, get_opcode_cost, Breakpoints, MiddlewareWithProtectedGlobals, + BREAKPOINT_VALUE_OUT_OF_GAS, +}; +use crate::we_helpers::{ + create_global_index, get_global_value_u64, is_control_flow_operator, set_global_value_u64, +}; +use multiversx_chain_vm_executor::OpcodeCost; +use std::mem; +use std::sync::{Arc, Mutex}; +use wasmer::sys::{FunctionMiddleware, MiddlewareReaderState, ModuleMiddleware}; +use wasmer::wasmparser::Operator; +use wasmer::{AsStoreMut, Instance, LocalFunctionIndex}; +use wasmer_types::{GlobalIndex, MiddlewareError, ModuleInfo}; + +const METERING_POINTS_LIMIT: &str = "metering_points_limit"; +const METERING_POINTS_USED: &str = "metering_points_used"; +const MAX_LOCAL_COUNT: u32 = 4000; + +#[derive(Clone, Debug)] +struct MeteringGlobalIndexes { + points_limit_global_index: GlobalIndex, + points_used_global_index: GlobalIndex, +} + +#[derive(Debug)] +pub(crate) struct Metering { + points_limit: u64, + unmetered_locals: usize, + opcode_cost: Arc, + breakpoints_middleware: Arc, + global_indexes: Mutex>, +} + +impl Metering { + pub(crate) fn new( + points_limit: u64, + unmetered_locals: usize, + opcode_cost: Arc, + breakpoints_middleware: Arc, + ) -> Self { + Self { + points_limit, + unmetered_locals, + opcode_cost, + breakpoints_middleware, + global_indexes: Mutex::new(None), + } + } + + pub fn get_points_limit_global_index(&self) -> GlobalIndex { + self.global_indexes + .lock() + .unwrap() + .as_ref() + .unwrap() + .points_limit_global_index + } + + pub fn get_points_used_global_index(&self) -> GlobalIndex { + self.global_indexes + .lock() + .unwrap() + .as_ref() + .unwrap() + .points_used_global_index + } +} + +unsafe impl Send for Metering {} +unsafe impl Sync for Metering {} + +impl ModuleMiddleware for Metering { + fn generate_function_middleware( + &self, + _local_function_index: LocalFunctionIndex, + ) -> Box { + Box::new(FunctionMetering { + accumulated_cost: Default::default(), + unmetered_locals: self.unmetered_locals, + opcode_cost: self.opcode_cost.clone(), + breakpoints_middleware: self.breakpoints_middleware.clone(), + global_indexes: self.global_indexes.lock().unwrap().clone().unwrap(), + }) + } + + fn transform_module_info(&self, module_info: &mut ModuleInfo) -> Result<(), MiddlewareError> { + let mut global_indexes = self.global_indexes.lock().unwrap(); + + let points_limit = self.points_limit as i64; + + *global_indexes = Some(MeteringGlobalIndexes { + points_limit_global_index: create_global_index( + module_info, + METERING_POINTS_LIMIT, + points_limit, + ), + points_used_global_index: create_global_index(module_info, METERING_POINTS_USED, 0), + }); + + Ok(()) + } +} + +#[derive(Debug)] +struct FunctionMetering { + accumulated_cost: u64, + unmetered_locals: usize, + opcode_cost: Arc, + breakpoints_middleware: Arc, + global_indexes: MeteringGlobalIndexes, +} + +impl FunctionMetering { + fn inject_points_used_increment(&self, state: &mut MiddlewareReaderState) { + state.extend(&[ + Operator::GlobalGet { + global_index: self.global_indexes.points_used_global_index.as_u32(), + }, + Operator::I64Const { + value: self.accumulated_cost as i64, + }, + Operator::I64Add, + Operator::GlobalSet { + global_index: self.global_indexes.points_used_global_index.as_u32(), + }, + ]); + } + + fn inject_out_of_gas_check(&self, state: &mut MiddlewareReaderState) { + state.extend(&[ + Operator::GlobalGet { + global_index: self.global_indexes.points_used_global_index.as_u32(), + }, + Operator::GlobalGet { + global_index: self.global_indexes.points_limit_global_index.as_u32(), + }, + Operator::I64GeU, + ]); + self.breakpoints_middleware + .inject_breakpoint_condition(state, BREAKPOINT_VALUE_OUT_OF_GAS); + } +} + +impl FunctionMiddleware for FunctionMetering { + fn feed<'b>( + &mut self, + operator: Operator<'b>, + state: &mut MiddlewareReaderState<'b>, + ) -> Result<(), MiddlewareError> { + // Get the cost of the current operator, and add it to the accumulator. + // This needs to be done before the metering logic, to prevent operators like `Call` from escaping metering in some + // corner cases. + let option = get_opcode_cost(&operator, &self.opcode_cost); + match option { + Some(cost) => self.accumulated_cost += cost as u64, + None => { + return Err(MiddlewareError::new( + "metering_middleware", + format!("Unsupported operator: {operator:?}"), + )) + } + } + + if is_control_flow_operator(&operator) { + self.inject_points_used_increment(state); + self.inject_out_of_gas_check(state); + + self.accumulated_cost = 0; + } + + state.push_operator(operator); + + Ok(()) + } + + // TODO: local count not available in Wasmer, options are: + // a. find alternative + // b. PR to Wasmer that gets accepted + // c. fork Wasmer + + // fn feed_local_count(&mut self, count: u32) -> Result<(), MiddlewareError> { + // check_local_count_exceeded(count)?; + // let unmetered_locals = self.unmetered_locals as u32; + // if count > unmetered_locals { + // let metered_locals = count - unmetered_locals; + // let local_cost = get_local_cost(&self.opcode_cost.lock().unwrap()); + // let metered_locals_cost = metered_locals * local_cost; + // self.accumulated_cost += metered_locals_cost as u64; + // } + // Ok(()) + // } +} + +pub(crate) fn get_points_limit( + instance: &Instance, + store: &mut impl AsStoreMut, +) -> anyhow::Result { + get_global_value_u64(instance, store, METERING_POINTS_LIMIT) +} + +pub(crate) fn set_points_limit( + instance: &Instance, + store: &mut impl AsStoreMut, + limit: u64, +) -> anyhow::Result<()> { + set_global_value_u64(instance, store, METERING_POINTS_LIMIT, limit) +} + +pub(crate) fn set_points_used( + instance: &Instance, + store: &mut impl AsStoreMut, + points: u64, +) -> anyhow::Result<()> { + set_global_value_u64(instance, store, METERING_POINTS_USED, points) +} + +pub(crate) fn get_points_used( + instance: &Instance, + store: &mut impl AsStoreMut, +) -> anyhow::Result { + get_global_value_u64(instance, store, METERING_POINTS_USED) +} + +fn check_local_count_exceeded(count: u32) -> Result<(), MiddlewareError> { + if count > MAX_LOCAL_COUNT { + return Err(MiddlewareError::new( + "metering_middleware", + format!("maximum number of locals({MAX_LOCAL_COUNT}) exceeded({count})"), + )); + } + + Ok(()) +} diff --git a/vm-executor-experimental/src/middlewares/we_metering_helpers.rs b/vm-executor-experimental/src/middlewares/we_metering_helpers.rs new file mode 100644 index 0000000..f2e895f --- /dev/null +++ b/vm-executor-experimental/src/middlewares/we_metering_helpers.rs @@ -0,0 +1,145 @@ +// Code generated by vmhooks generator. DO NOT EDIT. + +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +// !!!!!!!!!!!!!!!!!!!!!! AUTO-GENERATED FILE !!!!!!!!!!!!!!!!!!!!!! +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +use multiversx_chain_vm_executor::OpcodeCost; +use wasmer::wasmparser::Operator; + +pub fn get_local_cost(opcode_cost: &OpcodeCost) -> u32 { + opcode_cost.opcode_localallocate +} + +pub fn get_opcode_cost(op: &Operator, opcode_cost: &OpcodeCost) -> Option { + match op { + Operator::Block { .. } => Some(opcode_cost.opcode_block), + Operator::Br { .. } => Some(opcode_cost.opcode_br), + Operator::BrIf { .. } => Some(opcode_cost.opcode_brif), + Operator::BrTable { .. } => Some(opcode_cost.opcode_brtable), + Operator::Call { .. } => Some(opcode_cost.opcode_call), + Operator::CallIndirect { .. } => Some(opcode_cost.opcode_callindirect), + Operator::Catch { .. } => Some(opcode_cost.opcode_catch), + Operator::CatchAll { .. } => Some(opcode_cost.opcode_catchall), + Operator::Delegate { .. } => Some(opcode_cost.opcode_delegate), + Operator::Drop { .. } => Some(opcode_cost.opcode_drop), + Operator::Else { .. } => Some(opcode_cost.opcode_else), + Operator::End { .. } => Some(opcode_cost.opcode_end), + Operator::GlobalGet { .. } => Some(opcode_cost.opcode_globalget), + Operator::GlobalSet { .. } => Some(opcode_cost.opcode_globalset), + Operator::I32Add { .. } => Some(opcode_cost.opcode_i32add), + Operator::I32And { .. } => Some(opcode_cost.opcode_i32and), + Operator::I32Clz { .. } => Some(opcode_cost.opcode_i32clz), + Operator::I32Const { .. } => Some(opcode_cost.opcode_i32const), + Operator::I32Ctz { .. } => Some(opcode_cost.opcode_i32ctz), + Operator::I32DivS { .. } => Some(opcode_cost.opcode_i32divs), + Operator::I32DivU { .. } => Some(opcode_cost.opcode_i32divu), + Operator::I32Eq { .. } => Some(opcode_cost.opcode_i32eq), + Operator::I32Eqz { .. } => Some(opcode_cost.opcode_i32eqz), + Operator::I32Extend16S { .. } => Some(opcode_cost.opcode_i32extend16s), + Operator::I32Extend8S { .. } => Some(opcode_cost.opcode_i32extend8s), + Operator::I32GeS { .. } => Some(opcode_cost.opcode_i32ges), + Operator::I32GeU { .. } => Some(opcode_cost.opcode_i32geu), + Operator::I32GtS { .. } => Some(opcode_cost.opcode_i32gts), + Operator::I32GtU { .. } => Some(opcode_cost.opcode_i32gtu), + Operator::I32LeS { .. } => Some(opcode_cost.opcode_i32les), + Operator::I32LeU { .. } => Some(opcode_cost.opcode_i32leu), + Operator::I32Load { .. } => Some(opcode_cost.opcode_i32load), + Operator::I32Load16S { .. } => Some(opcode_cost.opcode_i32load16s), + Operator::I32Load16U { .. } => Some(opcode_cost.opcode_i32load16u), + Operator::I32Load8S { .. } => Some(opcode_cost.opcode_i32load8s), + Operator::I32Load8U { .. } => Some(opcode_cost.opcode_i32load8u), + Operator::I32LtS { .. } => Some(opcode_cost.opcode_i32lts), + Operator::I32LtU { .. } => Some(opcode_cost.opcode_i32ltu), + Operator::I32Mul { .. } => Some(opcode_cost.opcode_i32mul), + Operator::I32Ne { .. } => Some(opcode_cost.opcode_i32ne), + Operator::I32Or { .. } => Some(opcode_cost.opcode_i32or), + Operator::I32Popcnt { .. } => Some(opcode_cost.opcode_i32popcnt), + Operator::I32RemS { .. } => Some(opcode_cost.opcode_i32rems), + Operator::I32RemU { .. } => Some(opcode_cost.opcode_i32remu), + Operator::I32Rotl { .. } => Some(opcode_cost.opcode_i32rotl), + Operator::I32Rotr { .. } => Some(opcode_cost.opcode_i32rotr), + Operator::I32Shl { .. } => Some(opcode_cost.opcode_i32shl), + Operator::I32ShrS { .. } => Some(opcode_cost.opcode_i32shrs), + Operator::I32ShrU { .. } => Some(opcode_cost.opcode_i32shru), + Operator::I32Store { .. } => Some(opcode_cost.opcode_i32store), + Operator::I32Store16 { .. } => Some(opcode_cost.opcode_i32store16), + Operator::I32Store8 { .. } => Some(opcode_cost.opcode_i32store8), + Operator::I32Sub { .. } => Some(opcode_cost.opcode_i32sub), + Operator::I32WrapI64 { .. } => Some(opcode_cost.opcode_i32wrapi64), + Operator::I32Xor { .. } => Some(opcode_cost.opcode_i32xor), + Operator::I64Add { .. } => Some(opcode_cost.opcode_i64add), + Operator::I64And { .. } => Some(opcode_cost.opcode_i64and), + Operator::I64Clz { .. } => Some(opcode_cost.opcode_i64clz), + Operator::I64Const { .. } => Some(opcode_cost.opcode_i64const), + Operator::I64Ctz { .. } => Some(opcode_cost.opcode_i64ctz), + Operator::I64DivS { .. } => Some(opcode_cost.opcode_i64divs), + Operator::I64DivU { .. } => Some(opcode_cost.opcode_i64divu), + Operator::I64Eq { .. } => Some(opcode_cost.opcode_i64eq), + Operator::I64Eqz { .. } => Some(opcode_cost.opcode_i64eqz), + Operator::I64Extend16S { .. } => Some(opcode_cost.opcode_i64extend16s), + Operator::I64Extend32S { .. } => Some(opcode_cost.opcode_i64extend32s), + Operator::I64Extend8S { .. } => Some(opcode_cost.opcode_i64extend8s), + Operator::I64ExtendI32S { .. } => Some(opcode_cost.opcode_i64extendi32s), + Operator::I64ExtendI32U { .. } => Some(opcode_cost.opcode_i64extendi32u), + Operator::I64GeS { .. } => Some(opcode_cost.opcode_i64ges), + Operator::I64GeU { .. } => Some(opcode_cost.opcode_i64geu), + Operator::I64GtS { .. } => Some(opcode_cost.opcode_i64gts), + Operator::I64GtU { .. } => Some(opcode_cost.opcode_i64gtu), + Operator::I64LeS { .. } => Some(opcode_cost.opcode_i64les), + Operator::I64LeU { .. } => Some(opcode_cost.opcode_i64leu), + Operator::I64Load { .. } => Some(opcode_cost.opcode_i64load), + Operator::I64Load16S { .. } => Some(opcode_cost.opcode_i64load16s), + Operator::I64Load16U { .. } => Some(opcode_cost.opcode_i64load16u), + Operator::I64Load32S { .. } => Some(opcode_cost.opcode_i64load32s), + Operator::I64Load32U { .. } => Some(opcode_cost.opcode_i64load32u), + Operator::I64Load8S { .. } => Some(opcode_cost.opcode_i64load8s), + Operator::I64Load8U { .. } => Some(opcode_cost.opcode_i64load8u), + Operator::I64LtS { .. } => Some(opcode_cost.opcode_i64lts), + Operator::I64LtU { .. } => Some(opcode_cost.opcode_i64ltu), + Operator::I64Mul { .. } => Some(opcode_cost.opcode_i64mul), + Operator::I64Ne { .. } => Some(opcode_cost.opcode_i64ne), + Operator::I64Or { .. } => Some(opcode_cost.opcode_i64or), + Operator::I64Popcnt { .. } => Some(opcode_cost.opcode_i64popcnt), + Operator::I64RemS { .. } => Some(opcode_cost.opcode_i64rems), + Operator::I64RemU { .. } => Some(opcode_cost.opcode_i64remu), + Operator::I64Rotl { .. } => Some(opcode_cost.opcode_i64rotl), + Operator::I64Rotr { .. } => Some(opcode_cost.opcode_i64rotr), + Operator::I64Shl { .. } => Some(opcode_cost.opcode_i64shl), + Operator::I64ShrS { .. } => Some(opcode_cost.opcode_i64shrs), + Operator::I64ShrU { .. } => Some(opcode_cost.opcode_i64shru), + Operator::I64Store { .. } => Some(opcode_cost.opcode_i64store), + Operator::I64Store16 { .. } => Some(opcode_cost.opcode_i64store16), + Operator::I64Store32 { .. } => Some(opcode_cost.opcode_i64store32), + Operator::I64Store8 { .. } => Some(opcode_cost.opcode_i64store8), + Operator::I64Sub { .. } => Some(opcode_cost.opcode_i64sub), + Operator::I64Xor { .. } => Some(opcode_cost.opcode_i64xor), + Operator::If { .. } => Some(opcode_cost.opcode_if), + Operator::LocalGet { .. } => Some(opcode_cost.opcode_localget), + Operator::LocalSet { .. } => Some(opcode_cost.opcode_localset), + Operator::LocalTee { .. } => Some(opcode_cost.opcode_localtee), + Operator::Loop { .. } => Some(opcode_cost.opcode_loop), + Operator::MemoryGrow { .. } => Some(opcode_cost.opcode_memorygrow), + Operator::MemorySize { .. } => Some(opcode_cost.opcode_memorysize), + Operator::Nop { .. } => Some(opcode_cost.opcode_nop), + Operator::RefFunc { .. } => Some(opcode_cost.opcode_reffunc), + Operator::RefIsNull { .. } => Some(opcode_cost.opcode_refisnull), + Operator::RefNull { .. } => Some(opcode_cost.opcode_refnull), + Operator::Rethrow { .. } => Some(opcode_cost.opcode_rethrow), + Operator::Return { .. } => Some(opcode_cost.opcode_return), + Operator::ReturnCall { .. } => Some(opcode_cost.opcode_returncall), + Operator::ReturnCallIndirect { .. } => Some(opcode_cost.opcode_returncallindirect), + Operator::Select { .. } => Some(opcode_cost.opcode_select), + Operator::TableGet { .. } => Some(opcode_cost.opcode_tableget), + Operator::TableGrow { .. } => Some(opcode_cost.opcode_tablegrow), + Operator::TableInit { .. } => Some(opcode_cost.opcode_tableinit), + Operator::TableSet { .. } => Some(opcode_cost.opcode_tableset), + Operator::TableSize { .. } => Some(opcode_cost.opcode_tablesize), + Operator::Throw { .. } => Some(opcode_cost.opcode_throw), + Operator::Try { .. } => Some(opcode_cost.opcode_try), + Operator::TypedSelect { .. } => Some(opcode_cost.opcode_typedselect), + Operator::Unreachable { .. } => Some(opcode_cost.opcode_unreachable), + // Operator::Unwind { .. } => Some(opcode_cost.opcode_unwind), + _ => None, + } +} diff --git a/vm-executor-experimental/src/middlewares/we_opcode_control.rs b/vm-executor-experimental/src/middlewares/we_opcode_control.rs new file mode 100644 index 0000000..c22efaf --- /dev/null +++ b/vm-executor-experimental/src/middlewares/we_opcode_control.rs @@ -0,0 +1,210 @@ +use std::sync::{Arc, Mutex}; + +use wasmer::{ + sys::{FunctionMiddleware, MiddlewareReaderState, ModuleMiddleware}, + wasmparser::Operator, + LocalFunctionIndex, +}; +use wasmer_types::{GlobalIndex, MiddlewareError, ModuleInfo}; + +use crate::{ + // we_breakpoints::{Breakpoints, BREAKPOINT_VALUE_MEMORY_LIMIT}, + we_helpers::create_global_index, + // MiddlewareWithProtectedGlobals, +}; + +use super::{Breakpoints, BREAKPOINT_VALUE_MEMORY_LIMIT}; + +const OPCODE_CONTROL_MEMORY_GROW_COUNT: &str = "opcode_control_memory_grow_count"; +const OPCODE_CONTROL_OPERAND_BACKUP: &str = "opcode_control_operand_backup"; + +#[derive(Clone, Debug)] +struct OpcodeControlGlobalIndexes { + memory_grow_count_global_index: GlobalIndex, + operand_backup_global_index: GlobalIndex, +} + +#[derive(Debug)] +pub struct OpcodeControl { + total_memory_grow_count: Arc>, + max_memory_grow_count: usize, + max_memory_grow: usize, + max_memory_grow_delta: usize, + breakpoints_middleware: Arc, + global_indexes: Mutex>, +} + +impl OpcodeControl { + pub(crate) fn new( + max_memory_grow_count: usize, + max_memory_grow: usize, + max_memory_grow_delta: usize, + breakpoints_middleware: Arc, + ) -> Self { + Self { + total_memory_grow_count: Arc::new(Mutex::new(0)), + max_memory_grow_count, + max_memory_grow, + max_memory_grow_delta, + breakpoints_middleware, + global_indexes: Mutex::new(None), + } + } + + pub fn get_memory_grow_count_global_index(&self) -> GlobalIndex { + self.global_indexes + .lock() + .unwrap() + .as_ref() + .unwrap() + .memory_grow_count_global_index + } + + pub fn get_operand_backup_global_index(&self) -> GlobalIndex { + self.global_indexes + .lock() + .unwrap() + .as_ref() + .unwrap() + .operand_backup_global_index + } +} + +unsafe impl Send for OpcodeControl {} +unsafe impl Sync for OpcodeControl {} + +impl ModuleMiddleware for OpcodeControl { + fn generate_function_middleware( + &self, + _local_function_index: LocalFunctionIndex, + ) -> Box { + Box::new(FunctionOpcodeControl { + total_memory_grow_count: self.total_memory_grow_count.clone(), + max_memory_grow_count: self.max_memory_grow_count, + max_memory_grow: self.max_memory_grow, + max_memory_grow_delta: self.max_memory_grow_delta, + breakpoints_middleware: self.breakpoints_middleware.clone(), + global_indexes: self.global_indexes.lock().unwrap().clone().unwrap(), + }) + } + + fn transform_module_info(&self, module_info: &mut ModuleInfo) -> Result<(), MiddlewareError> { + let mut global_indexes = self.global_indexes.lock().unwrap(); + + *global_indexes = Some(OpcodeControlGlobalIndexes { + memory_grow_count_global_index: create_global_index( + module_info, + OPCODE_CONTROL_MEMORY_GROW_COUNT, + 0, + ), + operand_backup_global_index: create_global_index( + module_info, + OPCODE_CONTROL_OPERAND_BACKUP, + 0, + ), + }); + + Ok(()) + } +} + +#[derive(Debug)] +struct FunctionOpcodeControl { + total_memory_grow_count: Arc>, + max_memory_grow_count: usize, + max_memory_grow: usize, + max_memory_grow_delta: usize, + breakpoints_middleware: Arc, + global_indexes: OpcodeControlGlobalIndexes, +} + +impl FunctionOpcodeControl { + fn inject_memory_grow_limit_check(&self, state: &mut MiddlewareReaderState) { + state.extend(&[ + Operator::GlobalGet { + global_index: self.global_indexes.memory_grow_count_global_index.as_u32(), + }, + Operator::I64Const { + value: self.max_memory_grow as i64, + }, + Operator::I64GeU, + ]); + self.breakpoints_middleware + .inject_breakpoint_condition(state, BREAKPOINT_VALUE_MEMORY_LIMIT); + } + + fn inject_memory_grow_count_increment(&self, state: &mut MiddlewareReaderState) { + state.extend(&[ + Operator::GlobalGet { + global_index: self.global_indexes.memory_grow_count_global_index.as_u32(), + }, + Operator::I64Const { value: 1 }, + Operator::I64Add, + Operator::GlobalSet { + global_index: self.global_indexes.memory_grow_count_global_index.as_u32(), + }, + ]); + } + + fn inject_memory_grow_delta_limit_check(&self, state: &mut MiddlewareReaderState) { + state.extend(&[ + Operator::GlobalGet { + global_index: self.global_indexes.operand_backup_global_index.as_u32(), + }, + Operator::I64Const { + value: self.max_memory_grow_delta as i64, + }, + Operator::I64GtU, + ]); + + self.breakpoints_middleware + .inject_breakpoint_condition(state, BREAKPOINT_VALUE_MEMORY_LIMIT); + } + + fn inject_memory_grow_check(&self, state: &mut MiddlewareReaderState) { + self.inject_memory_grow_limit_check(state); + self.inject_memory_grow_count_increment(state); + + // Backup the top of the stack (the parameter for memory.grow) in order to + // duplicate it: once for the comparison against max_memory_grow_delta and + // again for memory.grow itself, assuming the comparison passes. + state.extend(&[Operator::GlobalSet { + global_index: self.global_indexes.operand_backup_global_index.as_u32(), + }]); + + self.inject_memory_grow_delta_limit_check(state); + + // Bring back the backed-up operand for memory.grow. + state.extend(&[Operator::GlobalGet { + global_index: self.global_indexes.operand_backup_global_index.as_u32(), + }]); + } +} + +impl FunctionMiddleware for FunctionOpcodeControl { + fn feed<'b>( + &mut self, + operator: Operator<'b>, + state: &mut MiddlewareReaderState<'b>, + ) -> Result<(), MiddlewareError> { + if matches!(operator, Operator::MemoryGrow { .. }) { + let mut grow_count = self + .total_memory_grow_count + .lock() + .map_err(|_| MiddlewareError::new("MemoryGrowLimit", "failed to lock counter"))?; + *grow_count += 1; + if *grow_count > self.max_memory_grow_count { + return Err(MiddlewareError::new( + "MemoryGrowLimit", + "memory.grow limit exceeded", + )); + } + + self.inject_memory_grow_check(state); + } + + state.push_operator(operator); + + Ok(()) + } +} diff --git a/vm-executor-experimental/src/middlewares/we_opcode_trace.rs b/vm-executor-experimental/src/middlewares/we_opcode_trace.rs new file mode 100644 index 0000000..49f25b9 --- /dev/null +++ b/vm-executor-experimental/src/middlewares/we_opcode_trace.rs @@ -0,0 +1,91 @@ +use loupe::{MemoryUsage, MemoryUsageTracker}; +use std::fs::{self, File}; +use std::io::Write; +use std::mem; +use wasmer::sys::{FunctionMiddleware, MiddlewareReaderState, ModuleMiddleware}; +use wasmer::wasmparser::Operator; +use wasmer::LocalFunctionIndex; +use wasmer_types::{MiddlewareError, ModuleInfo}; + +const OPCODE_TRACE_PATH: &str = "opcode.trace2"; + +#[derive(Debug)] +pub struct OpcodeTracer {} + +impl OpcodeTracer { + pub(crate) fn new() -> Self { + File::create(OPCODE_TRACE_PATH).unwrap(); + Self {} + } +} + +unsafe impl Send for OpcodeTracer {} +unsafe impl Sync for OpcodeTracer {} + +impl MemoryUsage for OpcodeTracer { + fn size_of_val(&self, _tracker: &mut dyn MemoryUsageTracker) -> usize { + mem::size_of_val(self) + } +} + +impl ModuleMiddleware for OpcodeTracer { + fn generate_function_middleware( + &self, + local_function_index: LocalFunctionIndex, + ) -> Box { + let file = fs::OpenOptions::new() + .append(true) + .open(OPCODE_TRACE_PATH) + .unwrap(); + + Box::new(FunctionOpcodeTracer { + output_file: file, + local_function_index: local_function_index.as_u32(), + counter: 0, + }) + } + + fn transform_module_info(&self, _module_info: &mut ModuleInfo) -> Result<(), MiddlewareError> { + Ok(()) + } +} + +#[derive(Debug)] +struct FunctionOpcodeTracer { + output_file: File, + local_function_index: u32, + counter: u32, +} + +impl FunctionOpcodeTracer { + fn trace_operator(&mut self, operator: &Operator) { + self.output_file + .write_all( + format!( + "[fn: {:08b}({}), operator: {:08b}({})]\t{:?}\n", + self.local_function_index, + self.local_function_index, + self.counter, + self.counter, + operator + ) + .as_bytes(), + ) + .unwrap(); + self.counter += 1; + } +} + +impl FunctionMiddleware for FunctionOpcodeTracer { + fn feed<'b>( + &mut self, + operator: Operator<'b>, + state: &mut MiddlewareReaderState<'b>, + ) -> Result<(), MiddlewareError> { + self.trace_operator(&operator); + + state.push_operator(operator); + + Ok(()) + } +} diff --git a/vm-executor-experimental/src/middlewares/we_protected_globals.rs b/vm-executor-experimental/src/middlewares/we_protected_globals.rs new file mode 100644 index 0000000..c7e0c58 --- /dev/null +++ b/vm-executor-experimental/src/middlewares/we_protected_globals.rs @@ -0,0 +1,93 @@ +use std::{mem, sync::Arc}; + +use loupe::{MemoryUsage, MemoryUsageTracker}; +use wasmer::{ + sys::{FunctionMiddleware, MiddlewareReaderState, ModuleMiddleware}, + wasmparser::Operator, + LocalFunctionIndex, +}; +use wasmer_types::{MiddlewareError, ModuleInfo}; + +use super::MiddlewareWithProtectedGlobals; + +#[derive(Debug)] +pub struct ProtectedGlobals { + protected_middlewares: Vec>, +} + +impl ProtectedGlobals { + pub(crate) fn new(protected_middlewares: Vec>) -> Self { + Self { + protected_middlewares, + } + } + + fn get_protected_globals(&self) -> Vec { + let mut protected_globals = vec![]; + for middleware in &self.protected_middlewares { + protected_globals.extend(middleware.protected_globals()) + } + protected_globals + } +} + +unsafe impl Send for ProtectedGlobals {} +unsafe impl Sync for ProtectedGlobals {} + +impl MemoryUsage for ProtectedGlobals { + fn size_of_val(&self, _tracker: &mut dyn MemoryUsageTracker) -> usize { + mem::size_of_val(self) + } +} + +impl ModuleMiddleware for ProtectedGlobals { + fn generate_function_middleware( + &self, + _local_function_index: LocalFunctionIndex, + ) -> Box { + Box::new(FunctionProtectedGlobals { + protected_globals: self.get_protected_globals(), + }) + } + + fn transform_module_info(&self, _module_info: &mut ModuleInfo) -> Result<(), MiddlewareError> { + Ok(()) + } +} + +#[derive(Debug)] +struct FunctionProtectedGlobals { + protected_globals: Vec, +} + +impl FunctionProtectedGlobals { + fn check_protected_globals_invalid_access( + &self, + operator: &Operator, + ) -> Result<(), MiddlewareError> { + if let Operator::GlobalSet { global_index } = *operator { + if self.protected_globals.contains(&global_index) { + return Err(MiddlewareError::new( + "protected_globals_middleware", + "protected globals invalid access", + )); + } + } + + Ok(()) + } +} + +impl FunctionMiddleware for FunctionProtectedGlobals { + fn feed<'b>( + &mut self, + operator: Operator<'b>, + state: &mut MiddlewareReaderState<'b>, + ) -> Result<(), MiddlewareError> { + self.check_protected_globals_invalid_access(&operator)?; + + state.push_operator(operator); + + Ok(()) + } +} diff --git a/vm-executor-experimental/src/middlewares/we_protected_globals_trait.rs b/vm-executor-experimental/src/middlewares/we_protected_globals_trait.rs new file mode 100644 index 0000000..482cc93 --- /dev/null +++ b/vm-executor-experimental/src/middlewares/we_protected_globals_trait.rs @@ -0,0 +1,31 @@ +use std::fmt::Debug; + +use super::{Breakpoints, Metering, OpcodeControl}; + +pub trait MiddlewareWithProtectedGlobals: Debug { + fn protected_globals(&self) -> Vec; +} + +impl MiddlewareWithProtectedGlobals for OpcodeControl { + fn protected_globals(&self) -> Vec { + vec![ + self.get_memory_grow_count_global_index().as_u32(), + self.get_operand_backup_global_index().as_u32(), + ] + } +} + +impl MiddlewareWithProtectedGlobals for Breakpoints { + fn protected_globals(&self) -> Vec { + vec![self.get_breakpoint_value_global_index().as_u32()] + } +} + +impl MiddlewareWithProtectedGlobals for Metering { + fn protected_globals(&self) -> Vec { + vec![ + self.get_points_limit_global_index().as_u32(), + self.get_points_used_global_index().as_u32(), + ] + } +} diff --git a/vm-executor-experimental/src/we_helpers.rs b/vm-executor-experimental/src/we_helpers.rs new file mode 100644 index 0000000..815e0a9 --- /dev/null +++ b/vm-executor-experimental/src/we_helpers.rs @@ -0,0 +1,66 @@ +use multiversx_chain_vm_executor::ExecutorError; +use wasmer::{ + wasmparser::Operator, AsStoreMut, ExportIndex, GlobalInit, GlobalType, Instance, Mutability, + Type, +}; +use wasmer_types::{GlobalIndex, ModuleInfo}; + +pub(crate) fn create_global_index( + module_info: &mut ModuleInfo, + key: &str, + init: i64, +) -> GlobalIndex { + let global_index = module_info + .globals + .push(GlobalType::new(Type::I64, Mutability::Var)); + + module_info + .global_initializers + .push(GlobalInit::I64Const(init)); + + module_info + .exports + .insert(key.to_string(), ExportIndex::Global(global_index)); + + global_index +} + +pub(crate) fn is_control_flow_operator(operator: &Operator) -> bool { + matches!( + operator, + Operator::Loop { .. } + | Operator::Block { .. } + | Operator::End + | Operator::If { .. } + | Operator::Else + | Operator::Unreachable + | Operator::Br { .. } + | Operator::BrTable { .. } + | Operator::BrIf { .. } + | Operator::Call { .. } + | Operator::CallIndirect { .. } + | Operator::Return + ) +} + +pub(crate) fn set_global_value_u64( + instance: &Instance, + store: &mut impl AsStoreMut, + global_name: &str, + value: u64, +) -> anyhow::Result<()> { + let global = instance.exports.get_global(global_name)?; + Ok(global.set(store, value.into())?) +} + +pub(crate) fn get_global_value_u64( + instance: &Instance, + store: &mut impl AsStoreMut, + global_name: &str, +) -> anyhow::Result { + let global = instance.exports.get_global(global_name)?; + let value = global.get(store); + value + .try_into() + .map_err(|err| anyhow::anyhow!("error parsing global value: {err}")) +} diff --git a/vm-executor-experimental/src/we_imports.rs b/vm-executor-experimental/src/we_imports.rs new file mode 100644 index 0000000..d8b1d2d --- /dev/null +++ b/vm-executor-experimental/src/we_imports.rs @@ -0,0 +1,1594 @@ +// Code generated by vmhooks generator. DO NOT EDIT. + +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +// !!!!!!!!!!!!!!!!!!!!!! AUTO-GENERATED FILE !!!!!!!!!!!!!!!!!!!!!! +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +#![allow(clippy::too_many_arguments)] + +use multiversx_chain_vm_executor::VMHooksError; +use wasmer::{imports, Function, FunctionEnv, FunctionEnvMut, Imports, Store}; + +use crate::we_vm_hooks::{convert_mem_length, convert_mem_ptr, with_vm_hooks, VMHooksWrapper}; + +#[rustfmt::skip] +fn wasmer_import_get_gas_left(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.get_gas_left()) +} + +#[rustfmt::skip] +fn wasmer_import_get_sc_address(env: FunctionEnvMut, result_offset: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.get_sc_address(convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_owner_address(env: FunctionEnvMut, result_offset: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.get_owner_address(convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_shard_of_address(env: FunctionEnvMut, address_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_shard_of_address(convert_mem_ptr(address_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_is_smart_contract(env: FunctionEnvMut, address_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.is_smart_contract(convert_mem_ptr(address_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_signal_error(env: FunctionEnvMut, message_offset: i32, message_length: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.signal_error(convert_mem_ptr(message_offset), convert_mem_length(message_length))) +} + +#[rustfmt::skip] +fn wasmer_import_get_external_balance(env: FunctionEnvMut, address_offset: i32, result_offset: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.get_external_balance(convert_mem_ptr(address_offset), convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_block_hash(env: FunctionEnvMut, nonce: i64, result_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_block_hash(nonce, convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_esdt_balance(env: FunctionEnvMut, address_offset: i32, token_id_offset: i32, token_id_len: i32, nonce: i64, result_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_esdt_balance(convert_mem_ptr(address_offset), convert_mem_ptr(token_id_offset), convert_mem_length(token_id_len), nonce, convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_esdt_nft_name_length(env: FunctionEnvMut, address_offset: i32, token_id_offset: i32, token_id_len: i32, nonce: i64) -> Result { + with_vm_hooks(env, |vh| vh.get_esdt_nft_name_length(convert_mem_ptr(address_offset), convert_mem_ptr(token_id_offset), convert_mem_length(token_id_len), nonce)) +} + +#[rustfmt::skip] +fn wasmer_import_get_esdt_nft_attribute_length(env: FunctionEnvMut, address_offset: i32, token_id_offset: i32, token_id_len: i32, nonce: i64) -> Result { + with_vm_hooks(env, |vh| vh.get_esdt_nft_attribute_length(convert_mem_ptr(address_offset), convert_mem_ptr(token_id_offset), convert_mem_length(token_id_len), nonce)) +} + +#[rustfmt::skip] +fn wasmer_import_get_esdt_nft_uri_length(env: FunctionEnvMut, address_offset: i32, token_id_offset: i32, token_id_len: i32, nonce: i64) -> Result { + with_vm_hooks(env, |vh| vh.get_esdt_nft_uri_length(convert_mem_ptr(address_offset), convert_mem_ptr(token_id_offset), convert_mem_length(token_id_len), nonce)) +} + +#[rustfmt::skip] +fn wasmer_import_get_esdt_token_data(env: FunctionEnvMut, address_offset: i32, token_id_offset: i32, token_id_len: i32, nonce: i64, value_handle: i32, properties_offset: i32, hash_offset: i32, name_offset: i32, attributes_offset: i32, creator_offset: i32, royalties_handle: i32, uris_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_esdt_token_data(convert_mem_ptr(address_offset), convert_mem_ptr(token_id_offset), convert_mem_length(token_id_len), nonce, value_handle, convert_mem_ptr(properties_offset), convert_mem_ptr(hash_offset), convert_mem_ptr(name_offset), convert_mem_ptr(attributes_offset), convert_mem_ptr(creator_offset), royalties_handle, convert_mem_ptr(uris_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_esdt_local_roles(env: FunctionEnvMut, token_id_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_esdt_local_roles(token_id_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_validate_token_identifier(env: FunctionEnvMut, token_id_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.validate_token_identifier(token_id_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_transfer_value(env: FunctionEnvMut, dest_offset: i32, value_offset: i32, data_offset: i32, length: i32) -> Result { + with_vm_hooks(env, |vh| vh.transfer_value(convert_mem_ptr(dest_offset), convert_mem_ptr(value_offset), convert_mem_ptr(data_offset), convert_mem_length(length))) +} + +#[rustfmt::skip] +fn wasmer_import_transfer_value_execute(env: FunctionEnvMut, dest_offset: i32, value_offset: i32, gas_limit: i64, function_offset: i32, function_length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.transfer_value_execute(convert_mem_ptr(dest_offset), convert_mem_ptr(value_offset), gas_limit, convert_mem_ptr(function_offset), convert_mem_length(function_length), num_arguments, convert_mem_ptr(arguments_length_offset), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_transfer_esdt_execute(env: FunctionEnvMut, dest_offset: i32, token_id_offset: i32, token_id_len: i32, value_offset: i32, gas_limit: i64, function_offset: i32, function_length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.transfer_esdt_execute(convert_mem_ptr(dest_offset), convert_mem_ptr(token_id_offset), convert_mem_length(token_id_len), convert_mem_ptr(value_offset), gas_limit, convert_mem_ptr(function_offset), convert_mem_length(function_length), num_arguments, convert_mem_ptr(arguments_length_offset), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_transfer_esdt_nft_execute(env: FunctionEnvMut, dest_offset: i32, token_id_offset: i32, token_id_len: i32, value_offset: i32, nonce: i64, gas_limit: i64, function_offset: i32, function_length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.transfer_esdt_nft_execute(convert_mem_ptr(dest_offset), convert_mem_ptr(token_id_offset), convert_mem_length(token_id_len), convert_mem_ptr(value_offset), nonce, gas_limit, convert_mem_ptr(function_offset), convert_mem_length(function_length), num_arguments, convert_mem_ptr(arguments_length_offset), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_multi_transfer_esdt_nft_execute(env: FunctionEnvMut, dest_offset: i32, num_token_transfers: i32, token_transfers_args_length_offset: i32, token_transfer_data_offset: i32, gas_limit: i64, function_offset: i32, function_length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.multi_transfer_esdt_nft_execute(convert_mem_ptr(dest_offset), num_token_transfers, convert_mem_ptr(token_transfers_args_length_offset), convert_mem_ptr(token_transfer_data_offset), gas_limit, convert_mem_ptr(function_offset), convert_mem_length(function_length), num_arguments, convert_mem_ptr(arguments_length_offset), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_create_async_call(env: FunctionEnvMut, dest_offset: i32, value_offset: i32, data_offset: i32, data_length: i32, success_offset: i32, success_length: i32, error_offset: i32, error_length: i32, gas: i64, extra_gas_for_callback: i64) -> Result { + with_vm_hooks(env, |vh| vh.create_async_call(convert_mem_ptr(dest_offset), convert_mem_ptr(value_offset), convert_mem_ptr(data_offset), convert_mem_length(data_length), convert_mem_ptr(success_offset), convert_mem_length(success_length), convert_mem_ptr(error_offset), convert_mem_length(error_length), gas, extra_gas_for_callback)) +} + +#[rustfmt::skip] +fn wasmer_import_set_async_context_callback(env: FunctionEnvMut, callback: i32, callback_length: i32, data: i32, data_length: i32, gas: i64) -> Result { + with_vm_hooks(env, |vh| vh.set_async_context_callback(convert_mem_ptr(callback), convert_mem_length(callback_length), convert_mem_ptr(data), convert_mem_length(data_length), gas)) +} + +#[rustfmt::skip] +fn wasmer_import_upgrade_contract(env: FunctionEnvMut, dest_offset: i32, gas_limit: i64, value_offset: i32, code_offset: i32, code_metadata_offset: i32, length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.upgrade_contract(convert_mem_ptr(dest_offset), gas_limit, convert_mem_ptr(value_offset), convert_mem_ptr(code_offset), convert_mem_ptr(code_metadata_offset), convert_mem_length(length), num_arguments, convert_mem_ptr(arguments_length_offset), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_upgrade_from_source_contract(env: FunctionEnvMut, dest_offset: i32, gas_limit: i64, value_offset: i32, source_contract_address_offset: i32, code_metadata_offset: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.upgrade_from_source_contract(convert_mem_ptr(dest_offset), gas_limit, convert_mem_ptr(value_offset), convert_mem_ptr(source_contract_address_offset), convert_mem_ptr(code_metadata_offset), num_arguments, convert_mem_ptr(arguments_length_offset), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_delete_contract(env: FunctionEnvMut, dest_offset: i32, gas_limit: i64, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.delete_contract(convert_mem_ptr(dest_offset), gas_limit, num_arguments, convert_mem_ptr(arguments_length_offset), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_async_call(env: FunctionEnvMut, dest_offset: i32, value_offset: i32, data_offset: i32, length: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.async_call(convert_mem_ptr(dest_offset), convert_mem_ptr(value_offset), convert_mem_ptr(data_offset), convert_mem_length(length))) +} + +#[rustfmt::skip] +fn wasmer_import_get_argument_length(env: FunctionEnvMut, id: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_argument_length(id)) +} + +#[rustfmt::skip] +fn wasmer_import_get_argument(env: FunctionEnvMut, id: i32, arg_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_argument(id, convert_mem_ptr(arg_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_function(env: FunctionEnvMut, function_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_function(convert_mem_ptr(function_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_num_arguments(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.get_num_arguments()) +} + +#[rustfmt::skip] +fn wasmer_import_storage_store(env: FunctionEnvMut, key_offset: i32, key_length: i32, data_offset: i32, data_length: i32) -> Result { + with_vm_hooks(env, |vh| vh.storage_store(convert_mem_ptr(key_offset), convert_mem_length(key_length), convert_mem_ptr(data_offset), convert_mem_length(data_length))) +} + +#[rustfmt::skip] +fn wasmer_import_storage_load_length(env: FunctionEnvMut, key_offset: i32, key_length: i32) -> Result { + with_vm_hooks(env, |vh| vh.storage_load_length(convert_mem_ptr(key_offset), convert_mem_length(key_length))) +} + +#[rustfmt::skip] +fn wasmer_import_storage_load_from_address(env: FunctionEnvMut, address_offset: i32, key_offset: i32, key_length: i32, data_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.storage_load_from_address(convert_mem_ptr(address_offset), convert_mem_ptr(key_offset), convert_mem_length(key_length), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_storage_load(env: FunctionEnvMut, key_offset: i32, key_length: i32, data_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.storage_load(convert_mem_ptr(key_offset), convert_mem_length(key_length), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_set_storage_lock(env: FunctionEnvMut, key_offset: i32, key_length: i32, lock_timestamp: i64) -> Result { + with_vm_hooks(env, |vh| vh.set_storage_lock(convert_mem_ptr(key_offset), convert_mem_length(key_length), lock_timestamp)) +} + +#[rustfmt::skip] +fn wasmer_import_get_storage_lock(env: FunctionEnvMut, key_offset: i32, key_length: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_storage_lock(convert_mem_ptr(key_offset), convert_mem_length(key_length))) +} + +#[rustfmt::skip] +fn wasmer_import_is_storage_locked(env: FunctionEnvMut, key_offset: i32, key_length: i32) -> Result { + with_vm_hooks(env, |vh| vh.is_storage_locked(convert_mem_ptr(key_offset), convert_mem_length(key_length))) +} + +#[rustfmt::skip] +fn wasmer_import_clear_storage_lock(env: FunctionEnvMut, key_offset: i32, key_length: i32) -> Result { + with_vm_hooks(env, |vh| vh.clear_storage_lock(convert_mem_ptr(key_offset), convert_mem_length(key_length))) +} + +#[rustfmt::skip] +fn wasmer_import_get_caller(env: FunctionEnvMut, result_offset: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.get_caller(convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_check_no_payment(env: FunctionEnvMut) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.check_no_payment()) +} + +#[rustfmt::skip] +fn wasmer_import_get_call_value(env: FunctionEnvMut, result_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_call_value(convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_esdt_value(env: FunctionEnvMut, result_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_esdt_value(convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_esdt_value_by_index(env: FunctionEnvMut, result_offset: i32, index: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_esdt_value_by_index(convert_mem_ptr(result_offset), index)) +} + +#[rustfmt::skip] +fn wasmer_import_get_esdt_token_name(env: FunctionEnvMut, result_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_esdt_token_name(convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_esdt_token_name_by_index(env: FunctionEnvMut, result_offset: i32, index: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_esdt_token_name_by_index(convert_mem_ptr(result_offset), index)) +} + +#[rustfmt::skip] +fn wasmer_import_get_esdt_token_nonce(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.get_esdt_token_nonce()) +} + +#[rustfmt::skip] +fn wasmer_import_get_esdt_token_nonce_by_index(env: FunctionEnvMut, index: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_esdt_token_nonce_by_index(index)) +} + +#[rustfmt::skip] +fn wasmer_import_get_current_esdt_nft_nonce(env: FunctionEnvMut, address_offset: i32, token_id_offset: i32, token_id_len: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_current_esdt_nft_nonce(convert_mem_ptr(address_offset), convert_mem_ptr(token_id_offset), convert_mem_length(token_id_len))) +} + +#[rustfmt::skip] +fn wasmer_import_get_esdt_token_type(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.get_esdt_token_type()) +} + +#[rustfmt::skip] +fn wasmer_import_get_esdt_token_type_by_index(env: FunctionEnvMut, index: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_esdt_token_type_by_index(index)) +} + +#[rustfmt::skip] +fn wasmer_import_get_num_esdt_transfers(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.get_num_esdt_transfers()) +} + +#[rustfmt::skip] +fn wasmer_import_get_call_value_token_name(env: FunctionEnvMut, call_value_offset: i32, token_name_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_call_value_token_name(convert_mem_ptr(call_value_offset), convert_mem_ptr(token_name_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_call_value_token_name_by_index(env: FunctionEnvMut, call_value_offset: i32, token_name_offset: i32, index: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_call_value_token_name_by_index(convert_mem_ptr(call_value_offset), convert_mem_ptr(token_name_offset), index)) +} + +#[rustfmt::skip] +fn wasmer_import_is_reserved_function_name(env: FunctionEnvMut, name_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.is_reserved_function_name(name_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_write_log(env: FunctionEnvMut, data_pointer: i32, data_length: i32, topic_ptr: i32, num_topics: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.write_log(convert_mem_ptr(data_pointer), convert_mem_length(data_length), convert_mem_ptr(topic_ptr), num_topics)) +} + +#[rustfmt::skip] +fn wasmer_import_write_event_log(env: FunctionEnvMut, num_topics: i32, topic_lengths_offset: i32, topic_offset: i32, data_offset: i32, data_length: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.write_event_log(num_topics, convert_mem_ptr(topic_lengths_offset), convert_mem_ptr(topic_offset), convert_mem_ptr(data_offset), convert_mem_length(data_length))) +} + +#[rustfmt::skip] +fn wasmer_import_get_block_timestamp(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.get_block_timestamp()) +} + +#[rustfmt::skip] +fn wasmer_import_get_block_nonce(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.get_block_nonce()) +} + +#[rustfmt::skip] +fn wasmer_import_get_block_round(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.get_block_round()) +} + +#[rustfmt::skip] +fn wasmer_import_get_block_epoch(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.get_block_epoch()) +} + +#[rustfmt::skip] +fn wasmer_import_get_block_random_seed(env: FunctionEnvMut, pointer: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.get_block_random_seed(convert_mem_ptr(pointer))) +} + +#[rustfmt::skip] +fn wasmer_import_get_state_root_hash(env: FunctionEnvMut, pointer: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.get_state_root_hash(convert_mem_ptr(pointer))) +} + +#[rustfmt::skip] +fn wasmer_import_get_prev_block_timestamp(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.get_prev_block_timestamp()) +} + +#[rustfmt::skip] +fn wasmer_import_get_prev_block_nonce(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.get_prev_block_nonce()) +} + +#[rustfmt::skip] +fn wasmer_import_get_prev_block_round(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.get_prev_block_round()) +} + +#[rustfmt::skip] +fn wasmer_import_get_prev_block_epoch(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.get_prev_block_epoch()) +} + +#[rustfmt::skip] +fn wasmer_import_get_prev_block_random_seed(env: FunctionEnvMut, pointer: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.get_prev_block_random_seed(convert_mem_ptr(pointer))) +} + +#[rustfmt::skip] +fn wasmer_import_finish(env: FunctionEnvMut, pointer: i32, length: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.finish(convert_mem_ptr(pointer), convert_mem_length(length))) +} + +#[rustfmt::skip] +fn wasmer_import_execute_on_same_context(env: FunctionEnvMut, gas_limit: i64, address_offset: i32, value_offset: i32, function_offset: i32, function_length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.execute_on_same_context(gas_limit, convert_mem_ptr(address_offset), convert_mem_ptr(value_offset), convert_mem_ptr(function_offset), convert_mem_length(function_length), num_arguments, convert_mem_ptr(arguments_length_offset), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_execute_on_dest_context(env: FunctionEnvMut, gas_limit: i64, address_offset: i32, value_offset: i32, function_offset: i32, function_length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.execute_on_dest_context(gas_limit, convert_mem_ptr(address_offset), convert_mem_ptr(value_offset), convert_mem_ptr(function_offset), convert_mem_length(function_length), num_arguments, convert_mem_ptr(arguments_length_offset), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_execute_read_only(env: FunctionEnvMut, gas_limit: i64, address_offset: i32, function_offset: i32, function_length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.execute_read_only(gas_limit, convert_mem_ptr(address_offset), convert_mem_ptr(function_offset), convert_mem_length(function_length), num_arguments, convert_mem_ptr(arguments_length_offset), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_create_contract(env: FunctionEnvMut, gas_limit: i64, value_offset: i32, code_offset: i32, code_metadata_offset: i32, length: i32, result_offset: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.create_contract(gas_limit, convert_mem_ptr(value_offset), convert_mem_ptr(code_offset), convert_mem_ptr(code_metadata_offset), convert_mem_length(length), convert_mem_ptr(result_offset), num_arguments, convert_mem_ptr(arguments_length_offset), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_deploy_from_source_contract(env: FunctionEnvMut, gas_limit: i64, value_offset: i32, source_contract_address_offset: i32, code_metadata_offset: i32, result_address_offset: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.deploy_from_source_contract(gas_limit, convert_mem_ptr(value_offset), convert_mem_ptr(source_contract_address_offset), convert_mem_ptr(code_metadata_offset), convert_mem_ptr(result_address_offset), num_arguments, convert_mem_ptr(arguments_length_offset), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_num_return_data(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.get_num_return_data()) +} + +#[rustfmt::skip] +fn wasmer_import_get_return_data_size(env: FunctionEnvMut, result_id: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_return_data_size(result_id)) +} + +#[rustfmt::skip] +fn wasmer_import_get_return_data(env: FunctionEnvMut, result_id: i32, data_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_return_data(result_id, convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_clean_return_data(env: FunctionEnvMut) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.clean_return_data()) +} + +#[rustfmt::skip] +fn wasmer_import_delete_from_return_data(env: FunctionEnvMut, result_id: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.delete_from_return_data(result_id)) +} + +#[rustfmt::skip] +fn wasmer_import_get_original_tx_hash(env: FunctionEnvMut, data_offset: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.get_original_tx_hash(convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_current_tx_hash(env: FunctionEnvMut, data_offset: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.get_current_tx_hash(convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_get_prev_tx_hash(env: FunctionEnvMut, data_offset: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.get_prev_tx_hash(convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_sc_address(env: FunctionEnvMut, destination_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_sc_address(destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_owner_address(env: FunctionEnvMut, destination_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_owner_address(destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_caller(env: FunctionEnvMut, destination_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_caller(destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_get_original_caller_addr(env: FunctionEnvMut, destination_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_get_original_caller_addr(destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_get_relayer_addr(env: FunctionEnvMut, destination_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_get_relayer_addr(destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_signal_error(env: FunctionEnvMut, err_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_signal_error(err_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_write_log(env: FunctionEnvMut, topics_handle: i32, data_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_write_log(topics_handle, data_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_get_original_tx_hash(env: FunctionEnvMut, result_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_get_original_tx_hash(result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_get_state_root_hash(env: FunctionEnvMut, result_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_get_state_root_hash(result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_get_block_random_seed(env: FunctionEnvMut, result_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_get_block_random_seed(result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_get_prev_block_random_seed(env: FunctionEnvMut, result_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_get_prev_block_random_seed(result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_get_return_data(env: FunctionEnvMut, result_id: i32, result_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_get_return_data(result_id, result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_get_multi_esdt_call_value(env: FunctionEnvMut, multi_call_value_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_get_multi_esdt_call_value(multi_call_value_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_get_back_transfers(env: FunctionEnvMut, esdt_transfers_value_handle: i32, egld_value_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_get_back_transfers(esdt_transfers_value_handle, egld_value_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_get_esdt_balance(env: FunctionEnvMut, address_handle: i32, token_id_handle: i32, nonce: i64, value_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_get_esdt_balance(address_handle, token_id_handle, nonce, value_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_get_esdt_token_data(env: FunctionEnvMut, 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<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_get_esdt_token_data(address_handle, token_id_handle, nonce, value_handle, properties_handle, hash_handle, name_handle, attributes_handle, creator_handle, royalties_handle, uris_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_async_call(env: FunctionEnvMut, dest_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_async_call(dest_handle, value_handle, function_handle, arguments_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_create_async_call(env: FunctionEnvMut, dest_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, success_offset: i32, success_length: i32, error_offset: i32, error_length: i32, gas: i64, extra_gas_for_callback: i64, callback_closure_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_create_async_call(dest_handle, value_handle, function_handle, arguments_handle, convert_mem_ptr(success_offset), convert_mem_length(success_length), convert_mem_ptr(error_offset), convert_mem_length(error_length), gas, extra_gas_for_callback, callback_closure_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_get_callback_closure(env: FunctionEnvMut, callback_closure_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_get_callback_closure(callback_closure_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_upgrade_from_source_contract(env: FunctionEnvMut, dest_handle: i32, gas: i64, value_handle: i32, address_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_upgrade_from_source_contract(dest_handle, gas, value_handle, address_handle, code_metadata_handle, arguments_handle, result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_upgrade_contract(env: FunctionEnvMut, dest_handle: i32, gas: i64, value_handle: i32, code_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_upgrade_contract(dest_handle, gas, value_handle, code_handle, code_metadata_handle, arguments_handle, result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_delete_contract(env: FunctionEnvMut, dest_handle: i32, gas_limit: i64, arguments_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_delete_contract(dest_handle, gas_limit, arguments_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_deploy_from_source_contract(env: FunctionEnvMut, gas: i64, value_handle: i32, address_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_address_handle: i32, result_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_deploy_from_source_contract(gas, value_handle, address_handle, code_metadata_handle, arguments_handle, result_address_handle, result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_create_contract(env: FunctionEnvMut, gas: i64, value_handle: i32, code_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_address_handle: i32, result_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_create_contract(gas, value_handle, code_handle, code_metadata_handle, arguments_handle, result_address_handle, result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_execute_read_only(env: FunctionEnvMut, gas: i64, address_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_execute_read_only(gas, address_handle, function_handle, arguments_handle, result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_execute_on_same_context(env: FunctionEnvMut, gas: i64, address_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_execute_on_same_context(gas, address_handle, value_handle, function_handle, arguments_handle, result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_execute_on_dest_context(env: FunctionEnvMut, gas: i64, address_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_execute_on_dest_context(gas, address_handle, value_handle, function_handle, arguments_handle, result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_multi_transfer_esdt_nft_execute(env: FunctionEnvMut, dst_handle: i32, token_transfers_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_multi_transfer_esdt_nft_execute(dst_handle, token_transfers_handle, gas_limit, function_handle, arguments_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_multi_transfer_esdt_nft_execute_by_user(env: FunctionEnvMut, user_handle: i32, dst_handle: i32, token_transfers_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_multi_transfer_esdt_nft_execute_by_user(user_handle, dst_handle, token_transfers_handle, gas_limit, function_handle, arguments_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_transfer_value_execute(env: FunctionEnvMut, dst_handle: i32, value_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_transfer_value_execute(dst_handle, value_handle, gas_limit, function_handle, arguments_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_is_esdt_frozen(env: FunctionEnvMut, address_handle: i32, token_id_handle: i32, nonce: i64) -> Result { + with_vm_hooks(env, |vh| vh.managed_is_esdt_frozen(address_handle, token_id_handle, nonce)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_is_esdt_limited_transfer(env: FunctionEnvMut, token_id_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_is_esdt_limited_transfer(token_id_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_is_esdt_paused(env: FunctionEnvMut, token_id_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_is_esdt_paused(token_id_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_buffer_to_hex(env: FunctionEnvMut, source_handle: i32, dest_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_buffer_to_hex(source_handle, dest_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_get_code_metadata(env: FunctionEnvMut, address_handle: i32, response_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.managed_get_code_metadata(address_handle, response_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_is_builtin_function(env: FunctionEnvMut, function_name_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_is_builtin_function(function_name_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_new_from_parts(env: FunctionEnvMut, integral_part: i32, fractional_part: i32, exponent: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_float_new_from_parts(integral_part, fractional_part, exponent)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_new_from_frac(env: FunctionEnvMut, numerator: i64, denominator: i64) -> Result { + with_vm_hooks(env, |vh| vh.big_float_new_from_frac(numerator, denominator)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_new_from_sci(env: FunctionEnvMut, significand: i64, exponent: i64) -> Result { + with_vm_hooks(env, |vh| vh.big_float_new_from_sci(significand, exponent)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_add(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_add(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_sub(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_sub(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_mul(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_mul(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_div(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_div(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_neg(env: FunctionEnvMut, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_neg(destination_handle, op_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_clone(env: FunctionEnvMut, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_clone(destination_handle, op_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_cmp(env: FunctionEnvMut, op1_handle: i32, op2_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_float_cmp(op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_abs(env: FunctionEnvMut, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_abs(destination_handle, op_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_sign(env: FunctionEnvMut, op_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_float_sign(op_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_sqrt(env: FunctionEnvMut, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_sqrt(destination_handle, op_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_pow(env: FunctionEnvMut, destination_handle: i32, op_handle: i32, exponent: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_pow(destination_handle, op_handle, exponent)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_floor(env: FunctionEnvMut, dest_big_int_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_floor(dest_big_int_handle, op_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_ceil(env: FunctionEnvMut, dest_big_int_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_ceil(dest_big_int_handle, op_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_truncate(env: FunctionEnvMut, dest_big_int_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_truncate(dest_big_int_handle, op_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_set_int64(env: FunctionEnvMut, destination_handle: i32, value: i64) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_set_int64(destination_handle, value)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_is_int(env: FunctionEnvMut, op_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_float_is_int(op_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_set_big_int(env: FunctionEnvMut, destination_handle: i32, big_int_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_set_big_int(destination_handle, big_int_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_get_const_pi(env: FunctionEnvMut, destination_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_get_const_pi(destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_float_get_const_e(env: FunctionEnvMut, destination_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_float_get_const_e(destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_get_unsigned_argument(env: FunctionEnvMut, id: i32, destination_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_get_unsigned_argument(id, destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_get_signed_argument(env: FunctionEnvMut, id: i32, destination_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_get_signed_argument(id, destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_storage_store_unsigned(env: FunctionEnvMut, key_offset: i32, key_length: i32, source_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_int_storage_store_unsigned(convert_mem_ptr(key_offset), convert_mem_length(key_length), source_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_storage_load_unsigned(env: FunctionEnvMut, key_offset: i32, key_length: i32, destination_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_int_storage_load_unsigned(convert_mem_ptr(key_offset), convert_mem_length(key_length), destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_get_call_value(env: FunctionEnvMut, destination_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_get_call_value(destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_get_esdt_call_value(env: FunctionEnvMut, destination: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_get_esdt_call_value(destination)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_get_esdt_call_value_by_index(env: FunctionEnvMut, destination_handle: i32, index: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_get_esdt_call_value_by_index(destination_handle, index)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_get_external_balance(env: FunctionEnvMut, address_offset: i32, result: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_get_external_balance(convert_mem_ptr(address_offset), result)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_get_esdt_external_balance(env: FunctionEnvMut, address_offset: i32, token_id_offset: i32, token_id_len: i32, nonce: i64, result_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_get_esdt_external_balance(convert_mem_ptr(address_offset), convert_mem_ptr(token_id_offset), convert_mem_length(token_id_len), nonce, result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_new(env: FunctionEnvMut, small_value: i64) -> Result { + with_vm_hooks(env, |vh| vh.big_int_new(small_value)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_unsigned_byte_length(env: FunctionEnvMut, reference_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_int_unsigned_byte_length(reference_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_signed_byte_length(env: FunctionEnvMut, reference_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_int_signed_byte_length(reference_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_get_unsigned_bytes(env: FunctionEnvMut, reference_handle: i32, byte_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_int_get_unsigned_bytes(reference_handle, convert_mem_ptr(byte_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_get_signed_bytes(env: FunctionEnvMut, reference_handle: i32, byte_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_int_get_signed_bytes(reference_handle, convert_mem_ptr(byte_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_set_unsigned_bytes(env: FunctionEnvMut, destination_handle: i32, byte_offset: i32, byte_length: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_set_unsigned_bytes(destination_handle, convert_mem_ptr(byte_offset), convert_mem_length(byte_length))) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_set_signed_bytes(env: FunctionEnvMut, destination_handle: i32, byte_offset: i32, byte_length: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_set_signed_bytes(destination_handle, convert_mem_ptr(byte_offset), convert_mem_length(byte_length))) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_is_int64(env: FunctionEnvMut, destination_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_int_is_int64(destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_get_int64(env: FunctionEnvMut, destination_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_int_get_int64(destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_set_int64(env: FunctionEnvMut, destination_handle: i32, value: i64) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_set_int64(destination_handle, value)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_add(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_add(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_sub(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_sub(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_mul(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_mul(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_tdiv(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_tdiv(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_tmod(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_tmod(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_ediv(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_ediv(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_emod(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_emod(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_sqrt(env: FunctionEnvMut, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_sqrt(destination_handle, op_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_pow(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_pow(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_log2(env: FunctionEnvMut, op1_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_int_log2(op1_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_abs(env: FunctionEnvMut, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_abs(destination_handle, op_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_neg(env: FunctionEnvMut, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_neg(destination_handle, op_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_sign(env: FunctionEnvMut, op_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_int_sign(op_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_cmp(env: FunctionEnvMut, op1_handle: i32, op2_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.big_int_cmp(op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_not(env: FunctionEnvMut, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_not(destination_handle, op_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_and(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_and(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_or(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_or(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_xor(env: FunctionEnvMut, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_xor(destination_handle, op1_handle, op2_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_shr(env: FunctionEnvMut, destination_handle: i32, op_handle: i32, bits: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_shr(destination_handle, op_handle, bits)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_shl(env: FunctionEnvMut, destination_handle: i32, op_handle: i32, bits: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_shl(destination_handle, op_handle, bits)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_finish_unsigned(env: FunctionEnvMut, reference_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_finish_unsigned(reference_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_finish_signed(env: FunctionEnvMut, reference_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_finish_signed(reference_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_big_int_to_string(env: FunctionEnvMut, big_int_handle: i32, destination_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.big_int_to_string(big_int_handle, destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_new(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_new()) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_new_from_bytes(env: FunctionEnvMut, data_offset: i32, data_length: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_new_from_bytes(convert_mem_ptr(data_offset), convert_mem_length(data_length))) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_get_length(env: FunctionEnvMut, m_buffer_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_get_length(m_buffer_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_get_bytes(env: FunctionEnvMut, m_buffer_handle: i32, result_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_get_bytes(m_buffer_handle, convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_get_byte_slice(env: FunctionEnvMut, source_handle: i32, starting_position: i32, slice_length: i32, result_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_get_byte_slice(source_handle, starting_position, slice_length, convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_copy_byte_slice(env: FunctionEnvMut, source_handle: i32, starting_position: i32, slice_length: i32, destination_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_copy_byte_slice(source_handle, starting_position, slice_length, destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_eq(env: FunctionEnvMut, m_buffer_handle1: i32, m_buffer_handle2: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_eq(m_buffer_handle1, m_buffer_handle2)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_set_bytes(env: FunctionEnvMut, m_buffer_handle: i32, data_offset: i32, data_length: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_set_bytes(m_buffer_handle, convert_mem_ptr(data_offset), convert_mem_length(data_length))) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_set_byte_slice(env: FunctionEnvMut, m_buffer_handle: i32, starting_position: i32, data_length: i32, data_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_set_byte_slice(m_buffer_handle, starting_position, convert_mem_length(data_length), convert_mem_ptr(data_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_append(env: FunctionEnvMut, accumulator_handle: i32, data_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_append(accumulator_handle, data_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_append_bytes(env: FunctionEnvMut, accumulator_handle: i32, data_offset: i32, data_length: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_append_bytes(accumulator_handle, convert_mem_ptr(data_offset), convert_mem_length(data_length))) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_to_big_int_unsigned(env: FunctionEnvMut, m_buffer_handle: i32, big_int_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_to_big_int_unsigned(m_buffer_handle, big_int_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_to_big_int_signed(env: FunctionEnvMut, m_buffer_handle: i32, big_int_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_to_big_int_signed(m_buffer_handle, big_int_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_from_big_int_unsigned(env: FunctionEnvMut, m_buffer_handle: i32, big_int_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_from_big_int_unsigned(m_buffer_handle, big_int_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_from_big_int_signed(env: FunctionEnvMut, m_buffer_handle: i32, big_int_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_from_big_int_signed(m_buffer_handle, big_int_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_to_big_float(env: FunctionEnvMut, m_buffer_handle: i32, big_float_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_to_big_float(m_buffer_handle, big_float_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_from_big_float(env: FunctionEnvMut, m_buffer_handle: i32, big_float_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_from_big_float(m_buffer_handle, big_float_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_storage_store(env: FunctionEnvMut, key_handle: i32, source_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_storage_store(key_handle, source_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_storage_load(env: FunctionEnvMut, key_handle: i32, destination_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_storage_load(key_handle, destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_storage_load_from_address(env: FunctionEnvMut, address_handle: i32, key_handle: i32, destination_handle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.mbuffer_storage_load_from_address(address_handle, key_handle, destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_get_argument(env: FunctionEnvMut, id: i32, destination_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_get_argument(id, destination_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_finish(env: FunctionEnvMut, source_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_finish(source_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_mbuffer_set_random(env: FunctionEnvMut, destination_handle: i32, length: i32) -> Result { + with_vm_hooks(env, |vh| vh.mbuffer_set_random(destination_handle, length)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_map_new(env: FunctionEnvMut) -> Result { + with_vm_hooks(env, |vh| vh.managed_map_new()) +} + +#[rustfmt::skip] +fn wasmer_import_managed_map_put(env: FunctionEnvMut, m_map_handle: i32, key_handle: i32, value_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_map_put(m_map_handle, key_handle, value_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_map_get(env: FunctionEnvMut, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_map_get(m_map_handle, key_handle, out_value_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_map_remove(env: FunctionEnvMut, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_map_remove(m_map_handle, key_handle, out_value_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_map_contains(env: FunctionEnvMut, m_map_handle: i32, key_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_map_contains(m_map_handle, key_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_small_int_get_unsigned_argument(env: FunctionEnvMut, id: i32) -> Result { + with_vm_hooks(env, |vh| vh.small_int_get_unsigned_argument(id)) +} + +#[rustfmt::skip] +fn wasmer_import_small_int_get_signed_argument(env: FunctionEnvMut, id: i32) -> Result { + with_vm_hooks(env, |vh| vh.small_int_get_signed_argument(id)) +} + +#[rustfmt::skip] +fn wasmer_import_small_int_finish_unsigned(env: FunctionEnvMut, value: i64) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.small_int_finish_unsigned(value)) +} + +#[rustfmt::skip] +fn wasmer_import_small_int_finish_signed(env: FunctionEnvMut, value: i64) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.small_int_finish_signed(value)) +} + +#[rustfmt::skip] +fn wasmer_import_small_int_storage_store_unsigned(env: FunctionEnvMut, key_offset: i32, key_length: i32, value: i64) -> Result { + with_vm_hooks(env, |vh| vh.small_int_storage_store_unsigned(convert_mem_ptr(key_offset), convert_mem_length(key_length), value)) +} + +#[rustfmt::skip] +fn wasmer_import_small_int_storage_store_signed(env: FunctionEnvMut, key_offset: i32, key_length: i32, value: i64) -> Result { + with_vm_hooks(env, |vh| vh.small_int_storage_store_signed(convert_mem_ptr(key_offset), convert_mem_length(key_length), value)) +} + +#[rustfmt::skip] +fn wasmer_import_small_int_storage_load_unsigned(env: FunctionEnvMut, key_offset: i32, key_length: i32) -> Result { + with_vm_hooks(env, |vh| vh.small_int_storage_load_unsigned(convert_mem_ptr(key_offset), convert_mem_length(key_length))) +} + +#[rustfmt::skip] +fn wasmer_import_small_int_storage_load_signed(env: FunctionEnvMut, key_offset: i32, key_length: i32) -> Result { + with_vm_hooks(env, |vh| vh.small_int_storage_load_signed(convert_mem_ptr(key_offset), convert_mem_length(key_length))) +} + +#[rustfmt::skip] +fn wasmer_import_int64get_argument(env: FunctionEnvMut, id: i32) -> Result { + with_vm_hooks(env, |vh| vh.int64get_argument(id)) +} + +#[rustfmt::skip] +fn wasmer_import_int64finish(env: FunctionEnvMut, value: i64) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.int64finish(value)) +} + +#[rustfmt::skip] +fn wasmer_import_int64storage_store(env: FunctionEnvMut, key_offset: i32, key_length: i32, value: i64) -> Result { + with_vm_hooks(env, |vh| vh.int64storage_store(convert_mem_ptr(key_offset), convert_mem_length(key_length), value)) +} + +#[rustfmt::skip] +fn wasmer_import_int64storage_load(env: FunctionEnvMut, key_offset: i32, key_length: i32) -> Result { + with_vm_hooks(env, |vh| vh.int64storage_load(convert_mem_ptr(key_offset), convert_mem_length(key_length))) +} + +#[rustfmt::skip] +fn wasmer_import_sha256(env: FunctionEnvMut, data_offset: i32, length: i32, result_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.sha256(convert_mem_ptr(data_offset), convert_mem_length(length), convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_sha256(env: FunctionEnvMut, input_handle: i32, output_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_sha256(input_handle, output_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_keccak256(env: FunctionEnvMut, data_offset: i32, length: i32, result_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.keccak256(convert_mem_ptr(data_offset), convert_mem_length(length), convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_keccak256(env: FunctionEnvMut, input_handle: i32, output_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_keccak256(input_handle, output_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_ripemd160(env: FunctionEnvMut, data_offset: i32, length: i32, result_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.ripemd160(convert_mem_ptr(data_offset), convert_mem_length(length), convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_ripemd160(env: FunctionEnvMut, input_handle: i32, output_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_ripemd160(input_handle, output_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_verify_bls(env: FunctionEnvMut, key_offset: i32, message_offset: i32, message_length: i32, sig_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.verify_bls(convert_mem_ptr(key_offset), convert_mem_ptr(message_offset), convert_mem_length(message_length), convert_mem_ptr(sig_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_verify_bls(env: FunctionEnvMut, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_verify_bls(key_handle, message_handle, sig_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_verify_ed25519(env: FunctionEnvMut, key_offset: i32, message_offset: i32, message_length: i32, sig_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.verify_ed25519(convert_mem_ptr(key_offset), convert_mem_ptr(message_offset), convert_mem_length(message_length), convert_mem_ptr(sig_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_verify_ed25519(env: FunctionEnvMut, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_verify_ed25519(key_handle, message_handle, sig_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_verify_custom_secp256k1(env: FunctionEnvMut, key_offset: i32, key_length: i32, message_offset: i32, message_length: i32, sig_offset: i32, hash_type: i32) -> Result { + with_vm_hooks(env, |vh| vh.verify_custom_secp256k1(convert_mem_ptr(key_offset), convert_mem_length(key_length), convert_mem_ptr(message_offset), convert_mem_length(message_length), convert_mem_ptr(sig_offset), hash_type)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_verify_custom_secp256k1(env: FunctionEnvMut, key_handle: i32, message_handle: i32, sig_handle: i32, hash_type: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_verify_custom_secp256k1(key_handle, message_handle, sig_handle, hash_type)) +} + +#[rustfmt::skip] +fn wasmer_import_verify_secp256k1(env: FunctionEnvMut, key_offset: i32, key_length: i32, message_offset: i32, message_length: i32, sig_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.verify_secp256k1(convert_mem_ptr(key_offset), convert_mem_length(key_length), convert_mem_ptr(message_offset), convert_mem_length(message_length), convert_mem_ptr(sig_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_verify_secp256k1(env: FunctionEnvMut, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_verify_secp256k1(key_handle, message_handle, sig_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_encode_secp256k1_der_signature(env: FunctionEnvMut, r_offset: i32, r_length: i32, s_offset: i32, s_length: i32, sig_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.encode_secp256k1_der_signature(convert_mem_ptr(r_offset), convert_mem_length(r_length), convert_mem_ptr(s_offset), convert_mem_length(s_length), convert_mem_ptr(sig_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_encode_secp256k1_der_signature(env: FunctionEnvMut, r_handle: i32, s_handle: i32, sig_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_encode_secp256k1_der_signature(r_handle, s_handle, sig_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_add_ec(env: FunctionEnvMut, 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<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.add_ec(x_result_handle, y_result_handle, ec_handle, fst_point_xhandle, fst_point_yhandle, snd_point_xhandle, snd_point_yhandle)) +} + +#[rustfmt::skip] +fn wasmer_import_double_ec(env: FunctionEnvMut, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) -> Result<(), VMHooksError> { + with_vm_hooks(env, |vh| vh.double_ec(x_result_handle, y_result_handle, ec_handle, point_xhandle, point_yhandle)) +} + +#[rustfmt::skip] +fn wasmer_import_is_on_curve_ec(env: FunctionEnvMut, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) -> Result { + with_vm_hooks(env, |vh| vh.is_on_curve_ec(ec_handle, point_xhandle, point_yhandle)) +} + +#[rustfmt::skip] +fn wasmer_import_scalar_base_mult_ec(env: FunctionEnvMut, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: i32, length: i32) -> Result { + with_vm_hooks(env, |vh| vh.scalar_base_mult_ec(x_result_handle, y_result_handle, ec_handle, convert_mem_ptr(data_offset), convert_mem_length(length))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_scalar_base_mult_ec(env: FunctionEnvMut, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_scalar_base_mult_ec(x_result_handle, y_result_handle, ec_handle, data_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_scalar_mult_ec(env: FunctionEnvMut, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32, data_offset: i32, length: i32) -> Result { + with_vm_hooks(env, |vh| vh.scalar_mult_ec(x_result_handle, y_result_handle, ec_handle, point_xhandle, point_yhandle, convert_mem_ptr(data_offset), convert_mem_length(length))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_scalar_mult_ec(env: FunctionEnvMut, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32, data_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_scalar_mult_ec(x_result_handle, y_result_handle, ec_handle, point_xhandle, point_yhandle, data_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_marshal_ec(env: FunctionEnvMut, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.marshal_ec(x_pair_handle, y_pair_handle, ec_handle, convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_marshal_ec(env: FunctionEnvMut, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_marshal_ec(x_pair_handle, y_pair_handle, ec_handle, result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_marshal_compressed_ec(env: FunctionEnvMut, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.marshal_compressed_ec(x_pair_handle, y_pair_handle, ec_handle, convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_marshal_compressed_ec(env: FunctionEnvMut, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_marshal_compressed_ec(x_pair_handle, y_pair_handle, ec_handle, result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_unmarshal_ec(env: FunctionEnvMut, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: i32, length: i32) -> Result { + with_vm_hooks(env, |vh| vh.unmarshal_ec(x_result_handle, y_result_handle, ec_handle, convert_mem_ptr(data_offset), convert_mem_length(length))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_unmarshal_ec(env: FunctionEnvMut, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_unmarshal_ec(x_result_handle, y_result_handle, ec_handle, data_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_unmarshal_compressed_ec(env: FunctionEnvMut, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: i32, length: i32) -> Result { + with_vm_hooks(env, |vh| vh.unmarshal_compressed_ec(x_result_handle, y_result_handle, ec_handle, convert_mem_ptr(data_offset), convert_mem_length(length))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_unmarshal_compressed_ec(env: FunctionEnvMut, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_unmarshal_compressed_ec(x_result_handle, y_result_handle, ec_handle, data_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_generate_key_ec(env: FunctionEnvMut, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_offset: i32) -> Result { + with_vm_hooks(env, |vh| vh.generate_key_ec(x_pub_key_handle, y_pub_key_handle, ec_handle, convert_mem_ptr(result_offset))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_generate_key_ec(env: FunctionEnvMut, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_generate_key_ec(x_pub_key_handle, y_pub_key_handle, ec_handle, result_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_create_ec(env: FunctionEnvMut, data_offset: i32, data_length: i32) -> Result { + with_vm_hooks(env, |vh| vh.create_ec(convert_mem_ptr(data_offset), convert_mem_length(data_length))) +} + +#[rustfmt::skip] +fn wasmer_import_managed_create_ec(env: FunctionEnvMut, data_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_create_ec(data_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_get_curve_length_ec(env: FunctionEnvMut, ec_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_curve_length_ec(ec_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_get_priv_key_byte_length_ec(env: FunctionEnvMut, ec_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.get_priv_key_byte_length_ec(ec_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_elliptic_curve_get_values(env: FunctionEnvMut, 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 { + with_vm_hooks(env, |vh| vh.elliptic_curve_get_values(ec_handle, field_order_handle, base_point_order_handle, eq_constant_handle, x_base_point_handle, y_base_point_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_verify_secp256r1(env: FunctionEnvMut, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_verify_secp256r1(key_handle, message_handle, sig_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_verify_blssignature_share(env: FunctionEnvMut, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_verify_blssignature_share(key_handle, message_handle, sig_handle)) +} + +#[rustfmt::skip] +fn wasmer_import_managed_verify_blsaggregated_signature(env: FunctionEnvMut, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result { + with_vm_hooks(env, |vh| vh.managed_verify_blsaggregated_signature(key_handle, message_handle, sig_handle)) +} + +pub fn generate_import_object(store: &mut Store, vh_wrapper: VMHooksWrapper) -> Imports { + let function_env = FunctionEnv::new(store, vh_wrapper); + + imports! { + "env" => { + "getGasLeft" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_gas_left), + "getSCAddress" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_sc_address), + "getOwnerAddress" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_owner_address), + "getShardOfAddress" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_shard_of_address), + "isSmartContract" => Function::new_typed_with_env(store, &function_env, wasmer_import_is_smart_contract), + "signalError" => Function::new_typed_with_env(store, &function_env, wasmer_import_signal_error), + "getExternalBalance" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_external_balance), + "getBlockHash" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_block_hash), + "getESDTBalance" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_esdt_balance), + "getESDTNFTNameLength" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_esdt_nft_name_length), + "getESDTNFTAttributeLength" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_esdt_nft_attribute_length), + "getESDTNFTURILength" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_esdt_nft_uri_length), + "getESDTTokenData" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_esdt_token_data), + "getESDTLocalRoles" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_esdt_local_roles), + "validateTokenIdentifier" => Function::new_typed_with_env(store, &function_env, wasmer_import_validate_token_identifier), + "transferValue" => Function::new_typed_with_env(store, &function_env, wasmer_import_transfer_value), + "transferValueExecute" => Function::new_typed_with_env(store, &function_env, wasmer_import_transfer_value_execute), + "transferESDTExecute" => Function::new_typed_with_env(store, &function_env, wasmer_import_transfer_esdt_execute), + "transferESDTNFTExecute" => Function::new_typed_with_env(store, &function_env, wasmer_import_transfer_esdt_nft_execute), + "multiTransferESDTNFTExecute" => Function::new_typed_with_env(store, &function_env, wasmer_import_multi_transfer_esdt_nft_execute), + "createAsyncCall" => Function::new_typed_with_env(store, &function_env, wasmer_import_create_async_call), + "setAsyncContextCallback" => Function::new_typed_with_env(store, &function_env, wasmer_import_set_async_context_callback), + "upgradeContract" => Function::new_typed_with_env(store, &function_env, wasmer_import_upgrade_contract), + "upgradeFromSourceContract" => Function::new_typed_with_env(store, &function_env, wasmer_import_upgrade_from_source_contract), + "deleteContract" => Function::new_typed_with_env(store, &function_env, wasmer_import_delete_contract), + "asyncCall" => Function::new_typed_with_env(store, &function_env, wasmer_import_async_call), + "getArgumentLength" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_argument_length), + "getArgument" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_argument), + "getFunction" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_function), + "getNumArguments" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_num_arguments), + "storageStore" => Function::new_typed_with_env(store, &function_env, wasmer_import_storage_store), + "storageLoadLength" => Function::new_typed_with_env(store, &function_env, wasmer_import_storage_load_length), + "storageLoadFromAddress" => Function::new_typed_with_env(store, &function_env, wasmer_import_storage_load_from_address), + "storageLoad" => Function::new_typed_with_env(store, &function_env, wasmer_import_storage_load), + "setStorageLock" => Function::new_typed_with_env(store, &function_env, wasmer_import_set_storage_lock), + "getStorageLock" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_storage_lock), + "isStorageLocked" => Function::new_typed_with_env(store, &function_env, wasmer_import_is_storage_locked), + "clearStorageLock" => Function::new_typed_with_env(store, &function_env, wasmer_import_clear_storage_lock), + "getCaller" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_caller), + "checkNoPayment" => Function::new_typed_with_env(store, &function_env, wasmer_import_check_no_payment), + "getCallValue" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_call_value), + "getESDTValue" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_esdt_value), + "getESDTValueByIndex" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_esdt_value_by_index), + "getESDTTokenName" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_esdt_token_name), + "getESDTTokenNameByIndex" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_esdt_token_name_by_index), + "getESDTTokenNonce" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_esdt_token_nonce), + "getESDTTokenNonceByIndex" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_esdt_token_nonce_by_index), + "getCurrentESDTNFTNonce" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_current_esdt_nft_nonce), + "getESDTTokenType" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_esdt_token_type), + "getESDTTokenTypeByIndex" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_esdt_token_type_by_index), + "getNumESDTTransfers" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_num_esdt_transfers), + "getCallValueTokenName" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_call_value_token_name), + "getCallValueTokenNameByIndex" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_call_value_token_name_by_index), + "isReservedFunctionName" => Function::new_typed_with_env(store, &function_env, wasmer_import_is_reserved_function_name), + "writeLog" => Function::new_typed_with_env(store, &function_env, wasmer_import_write_log), + "writeEventLog" => Function::new_typed_with_env(store, &function_env, wasmer_import_write_event_log), + "getBlockTimestamp" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_block_timestamp), + "getBlockNonce" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_block_nonce), + "getBlockRound" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_block_round), + "getBlockEpoch" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_block_epoch), + "getBlockRandomSeed" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_block_random_seed), + "getStateRootHash" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_state_root_hash), + "getPrevBlockTimestamp" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_prev_block_timestamp), + "getPrevBlockNonce" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_prev_block_nonce), + "getPrevBlockRound" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_prev_block_round), + "getPrevBlockEpoch" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_prev_block_epoch), + "getPrevBlockRandomSeed" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_prev_block_random_seed), + "finish" => Function::new_typed_with_env(store, &function_env, wasmer_import_finish), + "executeOnSameContext" => Function::new_typed_with_env(store, &function_env, wasmer_import_execute_on_same_context), + "executeOnDestContext" => Function::new_typed_with_env(store, &function_env, wasmer_import_execute_on_dest_context), + "executeReadOnly" => Function::new_typed_with_env(store, &function_env, wasmer_import_execute_read_only), + "createContract" => Function::new_typed_with_env(store, &function_env, wasmer_import_create_contract), + "deployFromSourceContract" => Function::new_typed_with_env(store, &function_env, wasmer_import_deploy_from_source_contract), + "getNumReturnData" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_num_return_data), + "getReturnDataSize" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_return_data_size), + "getReturnData" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_return_data), + "cleanReturnData" => Function::new_typed_with_env(store, &function_env, wasmer_import_clean_return_data), + "deleteFromReturnData" => Function::new_typed_with_env(store, &function_env, wasmer_import_delete_from_return_data), + "getOriginalTxHash" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_original_tx_hash), + "getCurrentTxHash" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_current_tx_hash), + "getPrevTxHash" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_prev_tx_hash), + "managedSCAddress" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_sc_address), + "managedOwnerAddress" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_owner_address), + "managedCaller" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_caller), + "managedGetOriginalCallerAddr" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_get_original_caller_addr), + "managedGetRelayerAddr" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_get_relayer_addr), + "managedSignalError" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_signal_error), + "managedWriteLog" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_write_log), + "managedGetOriginalTxHash" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_get_original_tx_hash), + "managedGetStateRootHash" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_get_state_root_hash), + "managedGetBlockRandomSeed" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_get_block_random_seed), + "managedGetPrevBlockRandomSeed" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_get_prev_block_random_seed), + "managedGetReturnData" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_get_return_data), + "managedGetMultiESDTCallValue" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_get_multi_esdt_call_value), + "managedGetBackTransfers" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_get_back_transfers), + "managedGetESDTBalance" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_get_esdt_balance), + "managedGetESDTTokenData" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_get_esdt_token_data), + "managedAsyncCall" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_async_call), + "managedCreateAsyncCall" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_create_async_call), + "managedGetCallbackClosure" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_get_callback_closure), + "managedUpgradeFromSourceContract" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_upgrade_from_source_contract), + "managedUpgradeContract" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_upgrade_contract), + "managedDeleteContract" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_delete_contract), + "managedDeployFromSourceContract" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_deploy_from_source_contract), + "managedCreateContract" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_create_contract), + "managedExecuteReadOnly" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_execute_read_only), + "managedExecuteOnSameContext" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_execute_on_same_context), + "managedExecuteOnDestContext" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_execute_on_dest_context), + "managedMultiTransferESDTNFTExecute" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_multi_transfer_esdt_nft_execute), + "managedMultiTransferESDTNFTExecuteByUser" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_multi_transfer_esdt_nft_execute_by_user), + "managedTransferValueExecute" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_transfer_value_execute), + "managedIsESDTFrozen" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_is_esdt_frozen), + "managedIsESDTLimitedTransfer" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_is_esdt_limited_transfer), + "managedIsESDTPaused" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_is_esdt_paused), + "managedBufferToHex" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_buffer_to_hex), + "managedGetCodeMetadata" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_get_code_metadata), + "managedIsBuiltinFunction" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_is_builtin_function), + "bigFloatNewFromParts" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_new_from_parts), + "bigFloatNewFromFrac" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_new_from_frac), + "bigFloatNewFromSci" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_new_from_sci), + "bigFloatAdd" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_add), + "bigFloatSub" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_sub), + "bigFloatMul" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_mul), + "bigFloatDiv" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_div), + "bigFloatNeg" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_neg), + "bigFloatClone" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_clone), + "bigFloatCmp" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_cmp), + "bigFloatAbs" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_abs), + "bigFloatSign" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_sign), + "bigFloatSqrt" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_sqrt), + "bigFloatPow" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_pow), + "bigFloatFloor" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_floor), + "bigFloatCeil" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_ceil), + "bigFloatTruncate" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_truncate), + "bigFloatSetInt64" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_set_int64), + "bigFloatIsInt" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_is_int), + "bigFloatSetBigInt" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_set_big_int), + "bigFloatGetConstPi" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_get_const_pi), + "bigFloatGetConstE" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_float_get_const_e), + "bigIntGetUnsignedArgument" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_get_unsigned_argument), + "bigIntGetSignedArgument" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_get_signed_argument), + "bigIntStorageStoreUnsigned" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_storage_store_unsigned), + "bigIntStorageLoadUnsigned" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_storage_load_unsigned), + "bigIntGetCallValue" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_get_call_value), + "bigIntGetESDTCallValue" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_get_esdt_call_value), + "bigIntGetESDTCallValueByIndex" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_get_esdt_call_value_by_index), + "bigIntGetExternalBalance" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_get_external_balance), + "bigIntGetESDTExternalBalance" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_get_esdt_external_balance), + "bigIntNew" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_new), + "bigIntUnsignedByteLength" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_unsigned_byte_length), + "bigIntSignedByteLength" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_signed_byte_length), + "bigIntGetUnsignedBytes" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_get_unsigned_bytes), + "bigIntGetSignedBytes" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_get_signed_bytes), + "bigIntSetUnsignedBytes" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_set_unsigned_bytes), + "bigIntSetSignedBytes" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_set_signed_bytes), + "bigIntIsInt64" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_is_int64), + "bigIntGetInt64" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_get_int64), + "bigIntSetInt64" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_set_int64), + "bigIntAdd" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_add), + "bigIntSub" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_sub), + "bigIntMul" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_mul), + "bigIntTDiv" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_tdiv), + "bigIntTMod" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_tmod), + "bigIntEDiv" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_ediv), + "bigIntEMod" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_emod), + "bigIntSqrt" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_sqrt), + "bigIntPow" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_pow), + "bigIntLog2" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_log2), + "bigIntAbs" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_abs), + "bigIntNeg" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_neg), + "bigIntSign" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_sign), + "bigIntCmp" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_cmp), + "bigIntNot" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_not), + "bigIntAnd" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_and), + "bigIntOr" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_or), + "bigIntXor" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_xor), + "bigIntShr" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_shr), + "bigIntShl" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_shl), + "bigIntFinishUnsigned" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_finish_unsigned), + "bigIntFinishSigned" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_finish_signed), + "bigIntToString" => Function::new_typed_with_env(store, &function_env, wasmer_import_big_int_to_string), + "mBufferNew" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_new), + "mBufferNewFromBytes" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_new_from_bytes), + "mBufferGetLength" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_get_length), + "mBufferGetBytes" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_get_bytes), + "mBufferGetByteSlice" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_get_byte_slice), + "mBufferCopyByteSlice" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_copy_byte_slice), + "mBufferEq" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_eq), + "mBufferSetBytes" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_set_bytes), + "mBufferSetByteSlice" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_set_byte_slice), + "mBufferAppend" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_append), + "mBufferAppendBytes" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_append_bytes), + "mBufferToBigIntUnsigned" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_to_big_int_unsigned), + "mBufferToBigIntSigned" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_to_big_int_signed), + "mBufferFromBigIntUnsigned" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_from_big_int_unsigned), + "mBufferFromBigIntSigned" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_from_big_int_signed), + "mBufferToBigFloat" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_to_big_float), + "mBufferFromBigFloat" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_from_big_float), + "mBufferStorageStore" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_storage_store), + "mBufferStorageLoad" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_storage_load), + "mBufferStorageLoadFromAddress" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_storage_load_from_address), + "mBufferGetArgument" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_get_argument), + "mBufferFinish" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_finish), + "mBufferSetRandom" => Function::new_typed_with_env(store, &function_env, wasmer_import_mbuffer_set_random), + "managedMapNew" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_map_new), + "managedMapPut" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_map_put), + "managedMapGet" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_map_get), + "managedMapRemove" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_map_remove), + "managedMapContains" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_map_contains), + "smallIntGetUnsignedArgument" => Function::new_typed_with_env(store, &function_env, wasmer_import_small_int_get_unsigned_argument), + "smallIntGetSignedArgument" => Function::new_typed_with_env(store, &function_env, wasmer_import_small_int_get_signed_argument), + "smallIntFinishUnsigned" => Function::new_typed_with_env(store, &function_env, wasmer_import_small_int_finish_unsigned), + "smallIntFinishSigned" => Function::new_typed_with_env(store, &function_env, wasmer_import_small_int_finish_signed), + "smallIntStorageStoreUnsigned" => Function::new_typed_with_env(store, &function_env, wasmer_import_small_int_storage_store_unsigned), + "smallIntStorageStoreSigned" => Function::new_typed_with_env(store, &function_env, wasmer_import_small_int_storage_store_signed), + "smallIntStorageLoadUnsigned" => Function::new_typed_with_env(store, &function_env, wasmer_import_small_int_storage_load_unsigned), + "smallIntStorageLoadSigned" => Function::new_typed_with_env(store, &function_env, wasmer_import_small_int_storage_load_signed), + "int64getArgument" => Function::new_typed_with_env(store, &function_env, wasmer_import_int64get_argument), + "int64finish" => Function::new_typed_with_env(store, &function_env, wasmer_import_int64finish), + "int64storageStore" => Function::new_typed_with_env(store, &function_env, wasmer_import_int64storage_store), + "int64storageLoad" => Function::new_typed_with_env(store, &function_env, wasmer_import_int64storage_load), + "sha256" => Function::new_typed_with_env(store, &function_env, wasmer_import_sha256), + "managedSha256" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_sha256), + "keccak256" => Function::new_typed_with_env(store, &function_env, wasmer_import_keccak256), + "managedKeccak256" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_keccak256), + "ripemd160" => Function::new_typed_with_env(store, &function_env, wasmer_import_ripemd160), + "managedRipemd160" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_ripemd160), + "verifyBLS" => Function::new_typed_with_env(store, &function_env, wasmer_import_verify_bls), + "managedVerifyBLS" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_verify_bls), + "verifyEd25519" => Function::new_typed_with_env(store, &function_env, wasmer_import_verify_ed25519), + "managedVerifyEd25519" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_verify_ed25519), + "verifyCustomSecp256k1" => Function::new_typed_with_env(store, &function_env, wasmer_import_verify_custom_secp256k1), + "managedVerifyCustomSecp256k1" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_verify_custom_secp256k1), + "verifySecp256k1" => Function::new_typed_with_env(store, &function_env, wasmer_import_verify_secp256k1), + "managedVerifySecp256k1" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_verify_secp256k1), + "encodeSecp256k1DerSignature" => Function::new_typed_with_env(store, &function_env, wasmer_import_encode_secp256k1_der_signature), + "managedEncodeSecp256k1DerSignature" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_encode_secp256k1_der_signature), + "addEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_add_ec), + "doubleEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_double_ec), + "isOnCurveEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_is_on_curve_ec), + "scalarBaseMultEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_scalar_base_mult_ec), + "managedScalarBaseMultEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_scalar_base_mult_ec), + "scalarMultEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_scalar_mult_ec), + "managedScalarMultEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_scalar_mult_ec), + "marshalEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_marshal_ec), + "managedMarshalEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_marshal_ec), + "marshalCompressedEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_marshal_compressed_ec), + "managedMarshalCompressedEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_marshal_compressed_ec), + "unmarshalEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_unmarshal_ec), + "managedUnmarshalEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_unmarshal_ec), + "unmarshalCompressedEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_unmarshal_compressed_ec), + "managedUnmarshalCompressedEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_unmarshal_compressed_ec), + "generateKeyEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_generate_key_ec), + "managedGenerateKeyEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_generate_key_ec), + "createEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_create_ec), + "managedCreateEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_create_ec), + "getCurveLengthEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_curve_length_ec), + "getPrivKeyByteLengthEC" => Function::new_typed_with_env(store, &function_env, wasmer_import_get_priv_key_byte_length_ec), + "ellipticCurveGetValues" => Function::new_typed_with_env(store, &function_env, wasmer_import_elliptic_curve_get_values), + "managedVerifySecp256r1" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_verify_secp256r1), + "managedVerifyBLSSignatureShare" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_verify_blssignature_share), + "managedVerifyBLSAggregatedSignature" => Function::new_typed_with_env(store, &function_env, wasmer_import_managed_verify_blsaggregated_signature), + + } + } +} diff --git a/vm-executor-experimental/src/we_instance.rs b/vm-executor-experimental/src/we_instance.rs new file mode 100644 index 0000000..e5f089a --- /dev/null +++ b/vm-executor-experimental/src/we_instance.rs @@ -0,0 +1,330 @@ +#![allow(unused)] + +use crate::middlewares::{ + get_breakpoint_value, get_points_used, set_points_limit, Breakpoints, Metering, OpcodeControl, + OpcodeTracer, ProtectedGlobals, +}; +use crate::we_instance_state::ExperimentalInstanceState; +use crate::ExperimentalVMHooksBuilder; +use crate::{we_imports::generate_import_object, we_vm_hooks::VMHooksWrapper}; +use anyhow::anyhow; +use log::trace; +use multiversx_chain_vm_executor::{ + BreakpointValue, CompilationOptions, ExecutorError, Instance, InstanceCallError, + InstanceLegacy, InstanceState, OpcodeCost, ServiceError, VMHooksError, +}; +use multiversx_chain_vm_executor::{MemLength, MemPtr}; +use rc_new_cyclic_fallible::rc_new_cyclic_fallible; +use std::cell::RefCell; +use std::mem::MaybeUninit; +use std::ops::Deref; +use std::{rc::Rc, rc::Weak, sync::Arc}; +use wasmer::sys::{CompilerConfig, Singlepass}; +use wasmer::{imports, AsStoreMut, Extern, Memory, Module, Pages, Store, StoreMut}; + +const MAX_MEMORY_PAGES_ALLOWED: Pages = Pages(20); + +pub struct ExperimentalInstance { + wasmer_store: RefCell, + inner: Rc, +} + +pub struct ExperimentalInstanceInner { + pub wasmer_instance: wasmer::Instance, + pub memory_name: String, + pub gas_limit: u64, +} + +impl ExperimentalInstanceInner { + pub fn get_memory_ref(&self) -> Result<&wasmer::Memory, String> { + let result = self.wasmer_instance.exports.get_memory(&self.memory_name); + match result { + Ok(memory) => Ok(memory), + Err(err) => Err(err.to_string()), + } + } +} + +fn prepare_wasmer_instance_inner( + vm_hooks_builder: Box, + module: &Module, + store: &mut Store, + weak: &Weak, + gas_limit: u64, +) -> Result { + // Create an empty import object. + trace!("Generating imports ..."); + let vm_hooks_wrapper = VMHooksWrapper { + vm_hooks_builder, + wasmer_inner: weak.clone(), + }; + let import_object = generate_import_object(store, vm_hooks_wrapper); + + trace!("Instantiating WasmerInstance ..."); + let wasmer_instance = wasmer::Instance::new(store, module, &import_object)?; + + // Check that there is exactly one memory in the smart contract, no more, no less + let memories = get_memories(&wasmer_instance); + validate_memories(&memories)?; + + // At this point we know that there is exactly one memory + let memory = memories[0].1; + // Checks that the memory size is not greater than the maximum allowed + validate_memory(memory, store)?; + + trace!("WasmerMemory size: {:#?}", memory.view(&store).size()); + let memory_name = memories[0].0.clone(); + + Ok(ExperimentalInstanceInner { + wasmer_instance, + memory_name, + gas_limit, + }) +} + +impl ExperimentalInstance { + pub fn try_new_instance( + vm_hooks_builder: Box, + opcode_cost: Arc, + wasm_bytes: &[u8], + compilation_options: &CompilationOptions, + ) -> Result { + // Use Singlepass compiler with the default settings + let mut compiler = Singlepass::default(); + + // Push middlewares + push_middlewares(&mut compiler, compilation_options, opcode_cost); + + // Create the store + let mut store: Store = Store::new(compiler); + + trace!("Compiling module ..."); + let module = Module::new(&store, wasm_bytes)?; + + let inner = rc_new_cyclic_fallible(|weak| { + prepare_wasmer_instance_inner( + vm_hooks_builder, + &module, + &mut store, + weak, + compilation_options.gas_limit, + ) + })?; + + Ok(ExperimentalInstance { + wasmer_store: RefCell::new(store), + inner, + }) + } +} + +fn get_memory_ref<'a>( + wasmer_instance: &'a wasmer::Instance, + memory_name: &'a str, +) -> Result<&'a wasmer::Memory, String> { + let result = wasmer_instance.exports.get_memory(memory_name); + match result { + Ok(memory) => Ok(memory), + Err(err) => Err(err.to_string()), + } +} + +fn get_memories(wasmer_instance: &wasmer::Instance) -> Vec<(&String, &wasmer::Memory)> { + let memories = wasmer_instance + .exports + .iter() + .memories() + .collect::>(); + memories +} + +fn validate_memories(memories: &[(&String, &wasmer::Memory)]) -> Result<(), ExecutorError> { + if memories.is_empty() { + return Err(Box::new(ServiceError::new( + "no memory declared in smart contract", + ))); + } + if memories.len() > 1 { + return Err(Box::new(ServiceError::new( + "more than one memory declared in smart contract", + ))); + } + + Ok(()) +} + +fn validate_memory(memory: &wasmer::Memory, store: &wasmer::Store) -> Result<(), ExecutorError> { + let memory_type = memory.ty(store); + let max_memory_pages = memory_type.maximum.unwrap_or(memory_type.minimum); + + if max_memory_pages > MAX_MEMORY_PAGES_ALLOWED { + trace!( + "Memory size exceeds maximum allowed: {:#?} > {:#?}", + max_memory_pages, + MAX_MEMORY_PAGES_ALLOWED + ); + return Err(Box::new(ServiceError::new( + "memory size exceeds maximum allowed", + ))); + } + + Ok(()) +} + +fn push_middlewares( + compiler: &mut Singlepass, + compilation_options: &CompilationOptions, + opcode_cost: Arc, +) { + // Create breakpoints middleware + let breakpoints_middleware = Arc::new(Breakpoints::new()); + + // Create opcode_control middleware + let opcode_control_middleware = Arc::new(OpcodeControl::new( + 100, // TODO: should be compilation_options.max_memory_grow_count, + compilation_options.max_memory_grow, + compilation_options.max_memory_grow_delta, + breakpoints_middleware.clone(), + )); + + // Create metering middleware + let metering_middleware = Arc::new(Metering::new( + compilation_options.gas_limit, + compilation_options.unmetered_locals, + opcode_cost, + breakpoints_middleware.clone(), + )); + + // Create protected_globals middleware + let protected_globals_middleware = Arc::new(ProtectedGlobals::new(vec![ + breakpoints_middleware.clone(), + metering_middleware.clone(), + ])); + + trace!("Adding protected_globals middleware ..."); + compiler.push_middleware(protected_globals_middleware); + trace!("Adding metering middleware ..."); + compiler.push_middleware(metering_middleware); + trace!("Adding opcode_control middleware ..."); + compiler.push_middleware(opcode_control_middleware); + trace!("Adding breakpoints middleware ..."); + compiler.push_middleware(breakpoints_middleware); + + if compilation_options.opcode_trace { + // Create opcode_tracer middleware + let opcode_tracer_middleware = Arc::new(OpcodeTracer::new()); + trace!("Adding opcode_tracer middleware ..."); + compiler.push_middleware(opcode_tracer_middleware); + } +} + +impl Instance for ExperimentalInstance { + fn call(&self, func_name: &str) -> Result<(), InstanceCallError> { + trace!("Rust instance call: {func_name}"); + + let func = self + .inner + .wasmer_instance + .exports + .get_function(func_name) + .map_err(|_| InstanceCallError::FunctionNotFound)?; + + match func.call(&mut *self.wasmer_store.borrow_mut(), &[]) { + Ok(_) => { + trace!("Call succeeded: {func_name}"); + Ok(()) + } + Err(runtime_error) => { + trace!("Call failed: {func_name} - {runtime_error}"); + + match runtime_error.downcast::() { + Ok(vm_hooks_error) => Err(InstanceCallError::VMHooksError(vm_hooks_error)), + Err(other_error) => { + let breakpoint = self + .get_breakpoint_value() + .expect("error retrieving instance breakpoint value"); + if breakpoint != BreakpointValue::None { + Err(InstanceCallError::Breakpoint(breakpoint)) + } else { + Err(InstanceCallError::RuntimeError( + anyhow!("runtime error {other_error}").into(), + )) + } + } + } + } + } + } + + fn check_signatures(&self) -> bool { + for (_, export) in self.inner.wasmer_instance.exports.iter() { + if let Extern::Function(endpoint) = export { + if endpoint.param_arity(&self.wasmer_store.borrow()) > 0 { + return false; + } + if endpoint.result_arity(&self.wasmer_store.borrow()) > 0 { + return false; + } + } + } + + true + } + + fn has_function(&self, func_name: &str) -> bool { + self.inner + .wasmer_instance + .exports + .get_function(func_name) + .is_ok() + } + + fn get_exported_function_names(&self) -> Vec { + self.inner + .wasmer_instance + .exports + .iter() + .filter_map(|(name, export)| match export { + Extern::Function(_) => Some(name), + _ => None, + }) + .cloned() + .collect() + } + + fn set_points_limit(&self, limit: u64) -> Result<(), ExecutorError> { + set_points_limit( + &self.inner.wasmer_instance, + &mut self.wasmer_store.borrow_mut(), + limit, + ) + .map_err(|err| err.into()) + } + + fn get_points_used(&self) -> Result { + get_points_used( + &self.inner.wasmer_instance, + &mut self.wasmer_store.borrow_mut(), + ) + .map_err(|err| err.into()) + } + + fn get_breakpoint_value(&self) -> Result { + let value = get_breakpoint_value( + &self.inner.wasmer_instance, + &mut self.wasmer_store.borrow_mut(), + )?; + value + .try_into() + .map_err(|err| anyhow!("error decoding breakpoint value: {err}").into()) + } + + fn reset(&self) -> Result<(), ExecutorError> { + panic!("ExperimentalInstance reset not supported") + } + + fn cache(&self) -> Result, ExecutorError> { + let module = self.inner.wasmer_instance.module(); + Ok(module.serialize()?.to_vec()) + } +} diff --git a/vm-executor-experimental/src/we_instance_state.rs b/vm-executor-experimental/src/we_instance_state.rs new file mode 100644 index 0000000..f6c87d9 --- /dev/null +++ b/vm-executor-experimental/src/we_instance_state.rs @@ -0,0 +1,93 @@ +#![allow(unused)] + +use crate::middlewares::{get_points_limit, set_breakpoint_value, set_points_used}; +use crate::ExperimentalInstanceInner; +use crate::{we_imports::generate_import_object, we_vm_hooks::VMHooksWrapper}; +use anyhow::anyhow; +use log::trace; +use multiversx_chain_vm_executor::{ + BreakpointValue, CompilationOptions, ExecutorError, InstanceLegacy, InstanceState, ServiceError, +}; +use multiversx_chain_vm_executor::{MemLength, MemPtr}; + +use std::cell::RefCell; +use std::ops::{Add, Deref}; +use std::rc::Weak; +use std::{rc::Rc, sync::Arc}; +use wasmer::{imports, AsStoreMut, Extern, MemoryView, Module, Pages, Store, StoreMut}; + +const MAX_MEMORY_PAGES_ALLOWED: Pages = Pages(20); + +pub struct ExperimentalInstanceState<'s> { + pub wasmer_inner: Weak, + pub store_mut: &'s mut StoreMut<'s>, + // pub breakpoint: BreakpointValue, + pub points_limit: u64, + pub points_used: u64, +} + +impl ExperimentalInstanceState<'_> { + fn get_memory_view(&self) -> MemoryView<'_> { + let wasmer_inner = self.wasmer_inner.upgrade().unwrap(); + wasmer_inner.get_memory_ref().unwrap().view(&self.store_mut) + } + + fn get_wasmer_inner(&self) -> Result, anyhow::Error> { + self.wasmer_inner + .upgrade() + .ok_or_else(|| anyhow!("uninitialized wasmer_inner weak pointer")) + } +} + +impl InstanceState for &'_ mut ExperimentalInstanceState<'_> { + fn get_points_limit(&self) -> Result { + Ok(self.points_limit) + } + + fn set_points_used(&mut self, points: u64) -> Result<(), ExecutorError> { + self.points_used = points; + Ok(()) + } + + fn get_points_used(&self) -> Result { + Ok(self.points_used) + } + + fn memory_load_to_slice(&self, mem_ptr: MemPtr, dest: &mut [u8]) -> Result<(), ExecutorError> { + let memory_view = self.get_memory_view(); + memory_view.read(mem_ptr as u64, dest)?; + Ok(()) + } + + /// Copies data to new owned buffer. + fn memory_load_owned( + &self, + mem_ptr: MemPtr, + mem_length: MemLength, + ) -> Result, ExecutorError> { + let memory_view = self.get_memory_view(); + let len = mem_length as usize; + let mut result = Vec::with_capacity(len); + memory_view.read_uninit(mem_ptr as u64, result.spare_capacity_mut()); + unsafe { + result.set_len(len); + } + Ok(result) + } + + fn memory_store(&self, offset: MemPtr, data: &[u8]) -> Result<(), ExecutorError> { + let memory_view = self.get_memory_view(); + memory_view.write(offset as u64, data)?; + Ok(()) + } + + fn set_breakpoint_value(&mut self, value: BreakpointValue) -> Result<(), ExecutorError> { + let wasmer_inner = self.get_wasmer_inner()?; + set_breakpoint_value( + &wasmer_inner.wasmer_instance, + self.store_mut, + value.as_u64(), + ) + .map_err(|err| err.into()) + } +} diff --git a/vm-executor-experimental/src/we_vm_hooks.rs b/vm-executor-experimental/src/we_vm_hooks.rs new file mode 100644 index 0000000..5ded361 --- /dev/null +++ b/vm-executor-experimental/src/we_vm_hooks.rs @@ -0,0 +1,64 @@ +use std::{ + cell::RefCell, + rc::{Rc, Weak}, +}; + +use multiversx_chain_vm_executor::{ + BreakpointValue, InstanceState, MemLength, MemPtr, VMHooks, VMHooksDefault, VMHooksError, +}; +use wasmer::FunctionEnvMut; + +use crate::{ + middlewares::{get_points_limit, get_points_used, set_breakpoint_value, set_points_used}, + ExperimentalInstanceInner, ExperimentalInstanceState, ExperimentalVMHooksBuilder, +}; + +pub struct VMHooksWrapper { + pub vm_hooks_builder: Box, + pub wasmer_inner: Weak, +} + +unsafe impl Send for VMHooksWrapper {} +unsafe impl Sync for VMHooksWrapper {} + +pub fn convert_mem_ptr(raw: i32) -> MemPtr { + raw as MemPtr +} + +pub fn convert_mem_length(raw: i32) -> MemLength { + raw as MemLength +} + +pub fn with_vm_hooks(mut env: FunctionEnvMut, f: F) -> Result +where + F: FnOnce(&mut dyn VMHooks) -> Result, + R: Default + 'static, +{ + let (data, mut store_mut) = env.data_and_store_mut(); + + let wasmer_inner = data.wasmer_inner.upgrade().unwrap(); + + let points_used = get_points_used(&wasmer_inner.wasmer_instance, &mut store_mut).unwrap(); + + let mut instance_state = ExperimentalInstanceState { + wasmer_inner: data.wasmer_inner.clone(), + store_mut: &mut store_mut, + points_limit: wasmer_inner.gas_limit, + points_used, + }; + + let mut vm_hooks = data.vm_hooks_builder.create_vm_hooks(&mut instance_state); + + let result = f(&mut *vm_hooks); + + std::mem::drop(vm_hooks); + + set_points_used( + &wasmer_inner.wasmer_instance, + &mut instance_state.store_mut, + instance_state.points_used, + ) + .unwrap(); + + result +} diff --git a/vm-executor-experimental/src/we_vm_hooks_builder.rs b/vm-executor-experimental/src/we_vm_hooks_builder.rs new file mode 100644 index 0000000..39d4d76 --- /dev/null +++ b/vm-executor-experimental/src/we_vm_hooks_builder.rs @@ -0,0 +1,22 @@ +use multiversx_chain_vm_executor::{VMHooks, VMHooksDefault}; + +use crate::ExperimentalInstanceState; + +pub trait ExperimentalVMHooksBuilder { + fn create_vm_hooks<'b, 'h>( + &'b self, + instance_state_ref: &'h mut ExperimentalInstanceState, + ) -> Box; +} + +#[derive(Debug)] +pub struct ExperimentalVMHooksBuilderDefault; + +impl ExperimentalVMHooksBuilder for ExperimentalVMHooksBuilderDefault { + fn create_vm_hooks<'b, 'h>( + &'b self, + _instance_state_ref: &'h mut ExperimentalInstanceState, + ) -> Box { + Box::new(VMHooksDefault) + } +} diff --git a/vm-executor-experimental/tests/common/mod.rs b/vm-executor-experimental/tests/common/mod.rs new file mode 100644 index 0000000..74d7a26 --- /dev/null +++ b/vm-executor-experimental/tests/common/mod.rs @@ -0,0 +1,7 @@ +mod test_instance; +mod test_wat; +mod test_wat_bad; + +pub use test_instance::*; +pub use test_wat::*; +pub use test_wat_bad::*; diff --git a/vm-executor-experimental/tests/common/test_instance.rs b/vm-executor-experimental/tests/common/test_instance.rs new file mode 100644 index 0000000..05ebfe2 --- /dev/null +++ b/vm-executor-experimental/tests/common/test_instance.rs @@ -0,0 +1,31 @@ +use std::sync::Arc; + +use multiversx_chain_vm_executor::{CompilationOptions, Instance, OpcodeCost}; +use multiversx_chain_vm_executor_wasmer_experimental::{ + ExperimentalInstance, ExperimentalVMHooksBuilderDefault, +}; +use wasmer::wat2wasm; + +const DUMMY_COMPILATION_OPTIONS: CompilationOptions = CompilationOptions { + gas_limit: 0, + unmetered_locals: 0, + max_memory_grow: 0, + max_memory_grow_delta: 0, + opcode_trace: false, + metering: false, + runtime_breakpoints: false, +}; + +pub fn test_instance(wat: &str) -> Box { + let wasm_bytes = wat2wasm(wat.as_bytes()).unwrap(); + + Box::new( + ExperimentalInstance::try_new_instance( + Box::new(ExperimentalVMHooksBuilderDefault), + Arc::new(OpcodeCost::default()), + &wasm_bytes, + &DUMMY_COMPILATION_OPTIONS, + ) + .unwrap(), + ) +} diff --git a/vm-executor-experimental/tests/common/test_wat.rs b/vm-executor-experimental/tests/common/test_wat.rs new file mode 100644 index 0000000..8e914d0 --- /dev/null +++ b/vm-executor-experimental/tests/common/test_wat.rs @@ -0,0 +1,164 @@ +pub const EMPTY_SC_WAT: &str = r#" +(module + (type (;0;) (func)) + (type (;1;) (func (param i32 i32))) + (type (;2;) (func (result i32))) + (import "env" "getNumArguments" (func (;0;) (type 2))) + (import "env" "signalError" (func (;1;) (type 1))) + (import "env" "checkNoPayment" (func (;2;) (type 0))) + (func (;3;) (type 0) + call 2 + call 0 + if ;; label = @1 + i32.const 1048576 + i32.const 25 + call 1 + unreachable + end) + (func (;4;) (type 0) + nop) + (memory (;0;) 17) + (global (;0;) i32 (i32.const 1048601)) + (global (;1;) i32 (i32.const 1048608)) + (export "memory" (memory 0)) + (export "init" (func 3)) + (export "callBack" (func 4)) + (export "__data_end" (global 0)) + (export "__heap_base" (global 1)) + (data (;0;) (i32.const 1048576) "wrong number of arguments")) +"#; + +/// The debug version, for an easier read. +pub const ADDER_WAT: &str = r#" +(module + (type (;0;) (func (param i32 i32))) + (type (;1;) (func (result i32))) + (type (;2;) (func (param i32 i32) (result i32))) + (type (;3;) (func (param i32 i32 i32) (result i32))) + (type (;4;) (func)) + (type (;5;) (func (param i32 i32 i32))) + (type (;6;) (func (param i32))) + (type (;7;) (func (param i32) (result i32))) + (import "env" "bigIntGetUnsignedArgument" (func $bigIntGetUnsignedArgument (type 0))) + (import "env" "getNumArguments" (func $getNumArguments (type 1))) + (import "env" "signalError" (func $signalError (type 0))) + (import "env" "mBufferStorageLoad" (func $mBufferStorageLoad (type 2))) + (import "env" "mBufferToBigIntUnsigned" (func $mBufferToBigIntUnsigned (type 2))) + (import "env" "mBufferFromBigIntUnsigned" (func $mBufferFromBigIntUnsigned (type 2))) + (import "env" "mBufferStorageStore" (func $mBufferStorageStore (type 2))) + (import "env" "mBufferSetBytes" (func $mBufferSetBytes (type 3))) + (import "env" "checkNoPayment" (func $checkNoPayment (type 4))) + (import "env" "bigIntAdd" (func $bigIntAdd (type 5))) + (import "env" "bigIntFinishUnsigned" (func $bigIntFinishUnsigned (type 6))) + (func $_ZN11elrond_wasm2io16arg_nested_tuple15load_single_arg17hc323659743ed9ee4E (type 1) (result i32) + (local i32) + i32.const 0 + call $_ZN16elrond_wasm_node3api13managed_types19static_var_api_node11next_handle17hdafd854c2ac6d869E + local.tee 0 + call $bigIntGetUnsignedArgument + local.get 0) + (func $_ZN16elrond_wasm_node3api13managed_types19static_var_api_node11next_handle17hdafd854c2ac6d869E (type 1) (result i32) + (local i32) + i32.const 0 + i32.const 0 + i32.load offset=1048604 + i32.const -1 + i32.add + local.tee 0 + i32.store offset=1048604 + local.get 0) + (func $_ZN11elrond_wasm2io16arg_nested_tuple22check_num_arguments_eq17h848f7f930a70d303E (type 6) (param i32) + block ;; label = @1 + call $getNumArguments + local.get 0 + i32.ne + br_if 0 (;@1;) + return + end + i32.const 1048576 + i32.const 25 + call $signalError + unreachable) + (func $_ZN11elrond_wasm7storage7mappers19single_value_mapper31SingleValueMapper$LT$SA$C$T$GT$3get17h25bb7558615ec585E (type 7) (param i32) (result i32) + (local i32) + local.get 0 + call $_ZN16elrond_wasm_node3api13managed_types19static_var_api_node11next_handle17hdafd854c2ac6d869E + local.tee 1 + call $mBufferStorageLoad + drop + local.get 1 + call $_ZN16elrond_wasm_node3api13managed_types19static_var_api_node11next_handle17hdafd854c2ac6d869E + local.tee 0 + call $mBufferToBigIntUnsigned + drop + local.get 0) + (func $_ZN11elrond_wasm7storage7mappers19single_value_mapper31SingleValueMapper$LT$SA$C$T$GT$3set17h646573d1e8aedfb8E (type 0) (param i32 i32) + (local i32) + call $_ZN16elrond_wasm_node3api13managed_types19static_var_api_node11next_handle17hdafd854c2ac6d869E + local.tee 2 + local.get 1 + call $mBufferFromBigIntUnsigned + drop + local.get 0 + local.get 2 + call $mBufferStorageStore + drop) + (func $_ZN34_$LT$C$u20$as$u20$adder..Adder$GT$3sum17h4be7469c9e0e8813E (type 1) (result i32) + (local i32) + call $_ZN16elrond_wasm_node3api13managed_types19static_var_api_node11next_handle17hdafd854c2ac6d869E + local.tee 0 + i32.const 1048601 + i32.const 3 + call $mBufferSetBytes + drop + local.get 0) + (func $init (type 4) + (local i32) + call $checkNoPayment + i32.const 1 + call $_ZN11elrond_wasm2io16arg_nested_tuple22check_num_arguments_eq17h848f7f930a70d303E + call $_ZN11elrond_wasm2io16arg_nested_tuple15load_single_arg17hc323659743ed9ee4E + local.set 0 + call $_ZN34_$LT$C$u20$as$u20$adder..Adder$GT$3sum17h4be7469c9e0e8813E + local.get 0 + call $_ZN11elrond_wasm7storage7mappers19single_value_mapper31SingleValueMapper$LT$SA$C$T$GT$3set17h646573d1e8aedfb8E) + (func $add (type 4) + (local i32 i32 i32) + call $checkNoPayment + i32.const 1 + call $_ZN11elrond_wasm2io16arg_nested_tuple22check_num_arguments_eq17h848f7f930a70d303E + call $_ZN11elrond_wasm2io16arg_nested_tuple15load_single_arg17hc323659743ed9ee4E + local.set 0 + call $_ZN34_$LT$C$u20$as$u20$adder..Adder$GT$3sum17h4be7469c9e0e8813E + local.tee 1 + call $_ZN11elrond_wasm7storage7mappers19single_value_mapper31SingleValueMapper$LT$SA$C$T$GT$3get17h25bb7558615ec585E + local.tee 2 + local.get 2 + local.get 0 + call $bigIntAdd + local.get 1 + local.get 2 + call $_ZN11elrond_wasm7storage7mappers19single_value_mapper31SingleValueMapper$LT$SA$C$T$GT$3set17h646573d1e8aedfb8E) + (func $getSum (type 4) + call $checkNoPayment + i32.const 0 + call $_ZN11elrond_wasm2io16arg_nested_tuple22check_num_arguments_eq17h848f7f930a70d303E + call $_ZN34_$LT$C$u20$as$u20$adder..Adder$GT$3sum17h4be7469c9e0e8813E + call $_ZN11elrond_wasm7storage7mappers19single_value_mapper31SingleValueMapper$LT$SA$C$T$GT$3get17h25bb7558615ec585E + call $bigIntFinishUnsigned) + (func $callBack (type 4)) + (table (;0;) 1 1 funcref) + (memory (;0;) 17) + (global $__stack_pointer (mut i32) (i32.const 1048576)) + (global (;1;) i32 (i32.const 1048608)) + (global (;2;) i32 (i32.const 1048608)) + (export "memory" (memory 0)) + (export "init" (func $init)) + (export "add" (func $add)) + (export "getSum" (func $getSum)) + (export "callBack" (func $callBack)) + (export "__data_end" (global 1)) + (export "__heap_base" (global 2)) + (data $.rodata (i32.const 1048576) "wrong number of argumentssum") + (data $.data (i32.const 1048604) "\9c\ff\ff\ff")) +"#; diff --git a/vm-executor-experimental/tests/common/test_wat_bad.rs b/vm-executor-experimental/tests/common/test_wat_bad.rs new file mode 100644 index 0000000..0ff0842 --- /dev/null +++ b/vm-executor-experimental/tests/common/test_wat_bad.rs @@ -0,0 +1,18 @@ +pub const BAD_INIT_PARAM: &str = r#" +(module + (type $t0 (func (param i32))) + (func $init (type $t0) (param $p0 i32)) + (memory $memory 2) + (export "memory" (memory 0)) + (export "init" (func $init))) +"#; + +pub const BAD_INIT_RESULT: &str = r#" +(module + (type (;0;) (func (result i32))) + (func (;0;) (type 0) (result i32) + i32.const 42) + (memory (;0;) 2) + (export "memory" (memory 0)) + (export "init" (func 0))) +"#; diff --git a/vm-executor-experimental/tests/endpoints_test.rs b/vm-executor-experimental/tests/endpoints_test.rs new file mode 100644 index 0000000..2e0551c --- /dev/null +++ b/vm-executor-experimental/tests/endpoints_test.rs @@ -0,0 +1,33 @@ +mod common; + +#[test] +fn instance_endpoints_empty() { + let instance = common::test_instance(common::EMPTY_SC_WAT); + assert_eq!( + instance.get_exported_function_names(), + vec!["init", "callBack"] + ); +} + +#[test] +fn instance_endpoints_adder() { + let instance = common::test_instance(common::ADDER_WAT); + assert!(instance.has_function("add")); + assert!(!instance.has_function("missingEndpoint")); + assert_eq!( + instance.get_exported_function_names(), + vec!["init", "add", "getSum", "callBack"] + ); +} + +#[test] +fn bad_init_param() { + let instance = common::test_instance(common::BAD_INIT_PARAM); + assert!(!instance.check_signatures()); +} + +#[test] +fn bad_init_result() { + let instance = common::test_instance(common::BAD_INIT_RESULT); + assert!(!instance.check_signatures()); +} diff --git a/vm-executor-wasmer/Cargo.toml b/vm-executor-wasmer/Cargo.toml index 992900d..3243a5a 100644 --- a/vm-executor-wasmer/Cargo.toml +++ b/vm-executor-wasmer/Cargo.toml @@ -24,3 +24,4 @@ wasmer-types = { git = "https://github.com/multiversx/wasmer", rev = "090ad17927 chrono = "0.4.23" log = "0.4.17" loupe = "0.1.3" +anyhow = "1.0" diff --git a/vm-executor-wasmer/src/wasmer_breakpoints.rs b/vm-executor-wasmer/src/wasmer_breakpoints.rs index 8a5e08c..09655f1 100644 --- a/vm-executor-wasmer/src/wasmer_breakpoints.rs +++ b/vm-executor-wasmer/src/wasmer_breakpoints.rs @@ -10,7 +10,8 @@ use wasmer::{ use wasmer_types::{GlobalIndex, ModuleInfo}; use crate::wasmer_helpers::{ - create_global_index, is_control_flow_operator, MiddlewareWithProtectedGlobals, + create_global_index, get_global_value_u64, is_control_flow_operator, set_global_value_u64, + MiddlewareWithProtectedGlobals, }; const BREAKPOINT_VALUE: &str = "breakpoint_value"; @@ -147,29 +148,9 @@ impl FunctionMiddleware for FunctionBreakpoints { } pub(crate) fn set_breakpoint_value(instance: &Instance, value: u64) -> Result<(), String> { - let result = instance.exports.get_global(BREAKPOINT_VALUE); - match result { - Ok(global) => { - let result = global.set(value.into()); - match result { - Ok(_) => Ok(()), - Err(err) => Err(err.message()), - } - } - Err(err) => Err(err.to_string()), - } + set_global_value_u64(instance, BREAKPOINT_VALUE, value) } pub(crate) fn get_breakpoint_value(instance: &Instance) -> Result { - let result = instance.exports.get_global(BREAKPOINT_VALUE); - match result { - Ok(global) => { - let result = global.get().try_into(); - match result { - Ok(value) => Ok(value), - Err(err) => Err(err.to_string()), - } - } - Err(err) => Err(err.to_string()), - } + get_global_value_u64(instance, BREAKPOINT_VALUE) } diff --git a/vm-executor-wasmer/src/wasmer_executor.rs b/vm-executor-wasmer/src/wasmer_executor.rs index c1442b6..0265eea 100644 --- a/vm-executor-wasmer/src/wasmer_executor.rs +++ b/vm-executor-wasmer/src/wasmer_executor.rs @@ -1,7 +1,8 @@ use crate::WasmerInstance; use log::trace; use multiversx_chain_vm_executor::{ - CompilationOptions, Executor, ExecutorError, Instance, OpcodeCost, ServiceError, VMHooks, + CompilationOptions, ExecutorError, ExecutorLegacy, InstanceLegacy, OpcodeCost, ServiceError, + VMHooksLegacy, }; use std::cell::RefCell; use std::ffi::c_void; @@ -16,22 +17,22 @@ pub fn force_sighandler_reinstall() { } } -pub(crate) struct WasmerExecutorData { - vm_hooks: Rc>, +pub struct WasmerExecutorData { + vm_hooks: Rc>>, opcode_cost: Arc>, } impl WasmerExecutorData { - fn new(vm_hooks: Box) -> Self { + pub fn new(vm_hooks: Box) -> Self { Self { - vm_hooks: Rc::new(vm_hooks), + vm_hooks: Rc::new(RefCell::new(vm_hooks)), opcode_cost: Arc::new(Mutex::new(OpcodeCost::default())), } } fn set_vm_hooks_ptr(&mut self, vm_hooks_ptr: *mut c_void) -> Result<(), ExecutorError> { if let Some(vm_hooks) = Rc::get_mut(&mut self.vm_hooks) { - vm_hooks.set_vm_hooks_ptr(vm_hooks_ptr); + vm_hooks.borrow_mut().set_vm_hooks_ptr(vm_hooks_ptr); Ok(()) } else { Err(Box::new(ServiceError::new( @@ -40,18 +41,10 @@ impl WasmerExecutorData { } } - fn set_opcode_cost(&mut self, opcode_cost: &OpcodeCost) -> Result<(), ExecutorError> { + pub fn set_opcode_cost(&mut self, opcode_cost: &OpcodeCost) -> Result<(), ExecutorError> { self.opcode_cost.lock().unwrap().clone_from(opcode_cost); Ok(()) } - - pub(crate) fn get_vm_hooks(&self) -> Rc> { - self.vm_hooks.clone() - } - - pub(crate) fn get_opcode_cost(&self) -> Arc> { - self.opcode_cost.clone() - } } pub struct WasmerExecutor { @@ -59,14 +52,14 @@ pub struct WasmerExecutor { } impl WasmerExecutor { - pub(crate) fn new(vm_hooks: Box) -> Self { + pub fn new(vm_hooks: Box) -> Self { Self { data: Rc::new(RefCell::new(WasmerExecutorData::new(vm_hooks))), } } } -impl Executor for WasmerExecutor { +impl ExecutorLegacy for WasmerExecutor { fn set_vm_hooks_ptr(&mut self, vm_hooks_ptr: *mut c_void) -> Result<(), ExecutorError> { trace!("Setting vmhooks ..."); self.data.borrow_mut().set_vm_hooks_ptr(vm_hooks_ptr) @@ -81,19 +74,29 @@ impl Executor for WasmerExecutor { &self, wasm_bytes: &[u8], compilation_options: &CompilationOptions, - ) -> Result, ExecutorError> { - WasmerInstance::try_new_instance(self.data.clone(), wasm_bytes, compilation_options) + ) -> Result, ExecutorError> { + let data = self.data.borrow(); + let instance = WasmerInstance::try_new_instance( + data.vm_hooks.clone(), + data.opcode_cost.clone(), + wasm_bytes, + compilation_options, + )?; + Ok(Box::new(instance)) } fn new_instance_from_cache( &self, cache_bytes: &[u8], compilation_options: &CompilationOptions, - ) -> Result, ExecutorError> { - WasmerInstance::try_new_instance_from_cache( - self.data.clone(), + ) -> Result, ExecutorError> { + let data = self.data.borrow(); + let instance = WasmerInstance::try_new_instance_from_cache( + data.vm_hooks.clone(), + data.opcode_cost.clone(), cache_bytes, compilation_options, - ) + )?; + Ok(Box::new(instance)) } } diff --git a/vm-executor-wasmer/src/wasmer_helpers.rs b/vm-executor-wasmer/src/wasmer_helpers.rs index 3e08d75..476a6aa 100644 --- a/vm-executor-wasmer/src/wasmer_helpers.rs +++ b/vm-executor-wasmer/src/wasmer_helpers.rs @@ -1,4 +1,6 @@ -use wasmer::{wasmparser::Operator, ExportIndex, GlobalInit, GlobalType, Mutability, Type}; +use wasmer::{ + wasmparser::Operator, ExportIndex, GlobalInit, GlobalType, Instance, Mutability, Type, +}; use wasmer_types::{GlobalIndex, ModuleInfo}; pub trait MiddlewareWithProtectedGlobals { @@ -31,6 +33,38 @@ pub(crate) fn create_global_index( global_index } +pub(crate) fn set_global_value_u64( + instance: &Instance, + global_name: &str, + points: u64, +) -> Result<(), String> { + let result = instance.exports.get_global(global_name); + match result { + Ok(global) => { + let result = global.set(points.into()); + match result { + Ok(_) => Ok(()), + Err(err) => Err(err.message()), + } + } + Err(err) => Err(err.to_string()), + } +} + +pub(crate) fn get_global_value_u64(instance: &Instance, global_name: &str) -> Result { + let result = instance.exports.get_global(global_name); + match result { + Ok(global) => { + let result = global.get().try_into(); + match result { + Ok(points) => Ok(points), + Err(err) => Err(err.to_string()), + } + } + Err(err) => Err(err.to_string()), + } +} + pub(crate) fn is_control_flow_operator(operator: &Operator) -> bool { matches!( operator, diff --git a/vm-executor-wasmer/src/wasmer_imports.rs b/vm-executor-wasmer/src/wasmer_imports.rs index 484676e..b02a0d1 100644 --- a/vm-executor-wasmer/src/wasmer_imports.rs +++ b/vm-executor-wasmer/src/wasmer_imports.rs @@ -12,1312 +12,1312 @@ use crate::wasmer_vm_hooks::VMHooksWrapper; #[rustfmt::skip] fn wasmer_import_get_gas_left(env: &VMHooksWrapper) -> i64 { - env.vm_hooks.get_gas_left() + env.with_vm_hooks(|vh| vh.get_gas_left()) } #[rustfmt::skip] fn wasmer_import_get_sc_address(env: &VMHooksWrapper, result_offset: i32) { - env.vm_hooks.get_sc_address(env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.get_sc_address(env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_get_owner_address(env: &VMHooksWrapper, result_offset: i32) { - env.vm_hooks.get_owner_address(env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.get_owner_address(env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_get_shard_of_address(env: &VMHooksWrapper, address_offset: i32) -> i32 { - env.vm_hooks.get_shard_of_address(env.convert_mem_ptr(address_offset)) + env.with_vm_hooks(|vh| vh.get_shard_of_address(env.convert_mem_ptr(address_offset))) } #[rustfmt::skip] fn wasmer_import_is_smart_contract(env: &VMHooksWrapper, address_offset: i32) -> i32 { - env.vm_hooks.is_smart_contract(env.convert_mem_ptr(address_offset)) + env.with_vm_hooks(|vh| vh.is_smart_contract(env.convert_mem_ptr(address_offset))) } #[rustfmt::skip] fn wasmer_import_signal_error(env: &VMHooksWrapper, message_offset: i32, message_length: i32) { - env.vm_hooks.signal_error(env.convert_mem_ptr(message_offset), env.convert_mem_length(message_length)) + env.with_vm_hooks(|vh| vh.signal_error(env.convert_mem_ptr(message_offset), env.convert_mem_length(message_length))) } #[rustfmt::skip] fn wasmer_import_get_external_balance(env: &VMHooksWrapper, address_offset: i32, result_offset: i32) { - env.vm_hooks.get_external_balance(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.get_external_balance(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_get_block_hash(env: &VMHooksWrapper, nonce: i64, result_offset: i32) -> i32 { - env.vm_hooks.get_block_hash(nonce, env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.get_block_hash(nonce, env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_get_esdt_balance(env: &VMHooksWrapper, address_offset: i32, token_id_offset: i32, token_id_len: i32, nonce: i64, result_offset: i32) -> i32 { - env.vm_hooks.get_esdt_balance(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), nonce, env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.get_esdt_balance(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), nonce, env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_get_esdt_nft_name_length(env: &VMHooksWrapper, address_offset: i32, token_id_offset: i32, token_id_len: i32, nonce: i64) -> i32 { - env.vm_hooks.get_esdt_nft_name_length(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), nonce) + env.with_vm_hooks(|vh| vh.get_esdt_nft_name_length(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), nonce)) } #[rustfmt::skip] fn wasmer_import_get_esdt_nft_attribute_length(env: &VMHooksWrapper, address_offset: i32, token_id_offset: i32, token_id_len: i32, nonce: i64) -> i32 { - env.vm_hooks.get_esdt_nft_attribute_length(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), nonce) + env.with_vm_hooks(|vh| vh.get_esdt_nft_attribute_length(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), nonce)) } #[rustfmt::skip] fn wasmer_import_get_esdt_nft_uri_length(env: &VMHooksWrapper, address_offset: i32, token_id_offset: i32, token_id_len: i32, nonce: i64) -> i32 { - env.vm_hooks.get_esdt_nft_uri_length(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), nonce) + env.with_vm_hooks(|vh| vh.get_esdt_nft_uri_length(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), nonce)) } #[rustfmt::skip] fn wasmer_import_get_esdt_token_data(env: &VMHooksWrapper, address_offset: i32, token_id_offset: i32, token_id_len: i32, nonce: i64, value_handle: i32, properties_offset: i32, hash_offset: i32, name_offset: i32, attributes_offset: i32, creator_offset: i32, royalties_handle: i32, uris_offset: i32) -> i32 { - env.vm_hooks.get_esdt_token_data(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), nonce, value_handle, env.convert_mem_ptr(properties_offset), env.convert_mem_ptr(hash_offset), env.convert_mem_ptr(name_offset), env.convert_mem_ptr(attributes_offset), env.convert_mem_ptr(creator_offset), royalties_handle, env.convert_mem_ptr(uris_offset)) + env.with_vm_hooks(|vh| vh.get_esdt_token_data(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), nonce, value_handle, env.convert_mem_ptr(properties_offset), env.convert_mem_ptr(hash_offset), env.convert_mem_ptr(name_offset), env.convert_mem_ptr(attributes_offset), env.convert_mem_ptr(creator_offset), royalties_handle, env.convert_mem_ptr(uris_offset))) } #[rustfmt::skip] fn wasmer_import_get_esdt_local_roles(env: &VMHooksWrapper, token_id_handle: i32) -> i64 { - env.vm_hooks.get_esdt_local_roles(token_id_handle) + env.with_vm_hooks(|vh| vh.get_esdt_local_roles(token_id_handle)) } #[rustfmt::skip] fn wasmer_import_validate_token_identifier(env: &VMHooksWrapper, token_id_handle: i32) -> i32 { - env.vm_hooks.validate_token_identifier(token_id_handle) + env.with_vm_hooks(|vh| vh.validate_token_identifier(token_id_handle)) } #[rustfmt::skip] fn wasmer_import_transfer_value(env: &VMHooksWrapper, dest_offset: i32, value_offset: i32, data_offset: i32, length: i32) -> i32 { - env.vm_hooks.transfer_value(env.convert_mem_ptr(dest_offset), env.convert_mem_ptr(value_offset), env.convert_mem_ptr(data_offset), env.convert_mem_length(length)) + env.with_vm_hooks(|vh| vh.transfer_value(env.convert_mem_ptr(dest_offset), env.convert_mem_ptr(value_offset), env.convert_mem_ptr(data_offset), env.convert_mem_length(length))) } #[rustfmt::skip] fn wasmer_import_transfer_value_execute(env: &VMHooksWrapper, dest_offset: i32, value_offset: i32, gas_limit: i64, function_offset: i32, function_length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> i32 { - env.vm_hooks.transfer_value_execute(env.convert_mem_ptr(dest_offset), env.convert_mem_ptr(value_offset), gas_limit, env.convert_mem_ptr(function_offset), env.convert_mem_length(function_length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.transfer_value_execute(env.convert_mem_ptr(dest_offset), env.convert_mem_ptr(value_offset), gas_limit, env.convert_mem_ptr(function_offset), env.convert_mem_length(function_length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_transfer_esdt_execute(env: &VMHooksWrapper, dest_offset: i32, token_id_offset: i32, token_id_len: i32, value_offset: i32, gas_limit: i64, function_offset: i32, function_length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> i32 { - env.vm_hooks.transfer_esdt_execute(env.convert_mem_ptr(dest_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), env.convert_mem_ptr(value_offset), gas_limit, env.convert_mem_ptr(function_offset), env.convert_mem_length(function_length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.transfer_esdt_execute(env.convert_mem_ptr(dest_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), env.convert_mem_ptr(value_offset), gas_limit, env.convert_mem_ptr(function_offset), env.convert_mem_length(function_length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_transfer_esdt_nft_execute(env: &VMHooksWrapper, dest_offset: i32, token_id_offset: i32, token_id_len: i32, value_offset: i32, nonce: i64, gas_limit: i64, function_offset: i32, function_length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> i32 { - env.vm_hooks.transfer_esdt_nft_execute(env.convert_mem_ptr(dest_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), env.convert_mem_ptr(value_offset), nonce, gas_limit, env.convert_mem_ptr(function_offset), env.convert_mem_length(function_length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.transfer_esdt_nft_execute(env.convert_mem_ptr(dest_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), env.convert_mem_ptr(value_offset), nonce, gas_limit, env.convert_mem_ptr(function_offset), env.convert_mem_length(function_length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_multi_transfer_esdt_nft_execute(env: &VMHooksWrapper, dest_offset: i32, num_token_transfers: i32, token_transfers_args_length_offset: i32, token_transfer_data_offset: i32, gas_limit: i64, function_offset: i32, function_length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> i32 { - env.vm_hooks.multi_transfer_esdt_nft_execute(env.convert_mem_ptr(dest_offset), num_token_transfers, env.convert_mem_ptr(token_transfers_args_length_offset), env.convert_mem_ptr(token_transfer_data_offset), gas_limit, env.convert_mem_ptr(function_offset), env.convert_mem_length(function_length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.multi_transfer_esdt_nft_execute(env.convert_mem_ptr(dest_offset), num_token_transfers, env.convert_mem_ptr(token_transfers_args_length_offset), env.convert_mem_ptr(token_transfer_data_offset), gas_limit, env.convert_mem_ptr(function_offset), env.convert_mem_length(function_length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_create_async_call(env: &VMHooksWrapper, dest_offset: i32, value_offset: i32, data_offset: i32, data_length: i32, success_offset: i32, success_length: i32, error_offset: i32, error_length: i32, gas: i64, extra_gas_for_callback: i64) -> i32 { - env.vm_hooks.create_async_call(env.convert_mem_ptr(dest_offset), env.convert_mem_ptr(value_offset), env.convert_mem_ptr(data_offset), env.convert_mem_length(data_length), env.convert_mem_ptr(success_offset), env.convert_mem_length(success_length), env.convert_mem_ptr(error_offset), env.convert_mem_length(error_length), gas, extra_gas_for_callback) + env.with_vm_hooks(|vh| vh.create_async_call(env.convert_mem_ptr(dest_offset), env.convert_mem_ptr(value_offset), env.convert_mem_ptr(data_offset), env.convert_mem_length(data_length), env.convert_mem_ptr(success_offset), env.convert_mem_length(success_length), env.convert_mem_ptr(error_offset), env.convert_mem_length(error_length), gas, extra_gas_for_callback)) } #[rustfmt::skip] fn wasmer_import_set_async_context_callback(env: &VMHooksWrapper, callback: i32, callback_length: i32, data: i32, data_length: i32, gas: i64) -> i32 { - env.vm_hooks.set_async_context_callback(env.convert_mem_ptr(callback), env.convert_mem_length(callback_length), env.convert_mem_ptr(data), env.convert_mem_length(data_length), gas) + env.with_vm_hooks(|vh| vh.set_async_context_callback(env.convert_mem_ptr(callback), env.convert_mem_length(callback_length), env.convert_mem_ptr(data), env.convert_mem_length(data_length), gas)) } #[rustfmt::skip] fn wasmer_import_upgrade_contract(env: &VMHooksWrapper, dest_offset: i32, gas_limit: i64, value_offset: i32, code_offset: i32, code_metadata_offset: i32, length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) { - env.vm_hooks.upgrade_contract(env.convert_mem_ptr(dest_offset), gas_limit, env.convert_mem_ptr(value_offset), env.convert_mem_ptr(code_offset), env.convert_mem_ptr(code_metadata_offset), env.convert_mem_length(length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.upgrade_contract(env.convert_mem_ptr(dest_offset), gas_limit, env.convert_mem_ptr(value_offset), env.convert_mem_ptr(code_offset), env.convert_mem_ptr(code_metadata_offset), env.convert_mem_length(length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_upgrade_from_source_contract(env: &VMHooksWrapper, dest_offset: i32, gas_limit: i64, value_offset: i32, source_contract_address_offset: i32, code_metadata_offset: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) { - env.vm_hooks.upgrade_from_source_contract(env.convert_mem_ptr(dest_offset), gas_limit, env.convert_mem_ptr(value_offset), env.convert_mem_ptr(source_contract_address_offset), env.convert_mem_ptr(code_metadata_offset), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.upgrade_from_source_contract(env.convert_mem_ptr(dest_offset), gas_limit, env.convert_mem_ptr(value_offset), env.convert_mem_ptr(source_contract_address_offset), env.convert_mem_ptr(code_metadata_offset), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_delete_contract(env: &VMHooksWrapper, dest_offset: i32, gas_limit: i64, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) { - env.vm_hooks.delete_contract(env.convert_mem_ptr(dest_offset), gas_limit, num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.delete_contract(env.convert_mem_ptr(dest_offset), gas_limit, num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_async_call(env: &VMHooksWrapper, dest_offset: i32, value_offset: i32, data_offset: i32, length: i32) { - env.vm_hooks.async_call(env.convert_mem_ptr(dest_offset), env.convert_mem_ptr(value_offset), env.convert_mem_ptr(data_offset), env.convert_mem_length(length)) + env.with_vm_hooks(|vh| vh.async_call(env.convert_mem_ptr(dest_offset), env.convert_mem_ptr(value_offset), env.convert_mem_ptr(data_offset), env.convert_mem_length(length))) } #[rustfmt::skip] fn wasmer_import_get_argument_length(env: &VMHooksWrapper, id: i32) -> i32 { - env.vm_hooks.get_argument_length(id) + env.with_vm_hooks(|vh| vh.get_argument_length(id)) } #[rustfmt::skip] fn wasmer_import_get_argument(env: &VMHooksWrapper, id: i32, arg_offset: i32) -> i32 { - env.vm_hooks.get_argument(id, env.convert_mem_ptr(arg_offset)) + env.with_vm_hooks(|vh| vh.get_argument(id, env.convert_mem_ptr(arg_offset))) } #[rustfmt::skip] fn wasmer_import_get_function(env: &VMHooksWrapper, function_offset: i32) -> i32 { - env.vm_hooks.get_function(env.convert_mem_ptr(function_offset)) + env.with_vm_hooks(|vh| vh.get_function(env.convert_mem_ptr(function_offset))) } #[rustfmt::skip] fn wasmer_import_get_num_arguments(env: &VMHooksWrapper) -> i32 { - env.vm_hooks.get_num_arguments() + env.with_vm_hooks(|vh| vh.get_num_arguments()) } #[rustfmt::skip] fn wasmer_import_storage_store(env: &VMHooksWrapper, key_offset: i32, key_length: i32, data_offset: i32, data_length: i32) -> i32 { - env.vm_hooks.storage_store(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), env.convert_mem_ptr(data_offset), env.convert_mem_length(data_length)) + env.with_vm_hooks(|vh| vh.storage_store(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), env.convert_mem_ptr(data_offset), env.convert_mem_length(data_length))) } #[rustfmt::skip] fn wasmer_import_storage_load_length(env: &VMHooksWrapper, key_offset: i32, key_length: i32) -> i32 { - env.vm_hooks.storage_load_length(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length)) + env.with_vm_hooks(|vh| vh.storage_load_length(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length))) } #[rustfmt::skip] fn wasmer_import_storage_load_from_address(env: &VMHooksWrapper, address_offset: i32, key_offset: i32, key_length: i32, data_offset: i32) -> i32 { - env.vm_hooks.storage_load_from_address(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.storage_load_from_address(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_storage_load(env: &VMHooksWrapper, key_offset: i32, key_length: i32, data_offset: i32) -> i32 { - env.vm_hooks.storage_load(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.storage_load(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_set_storage_lock(env: &VMHooksWrapper, key_offset: i32, key_length: i32, lock_timestamp: i64) -> i32 { - env.vm_hooks.set_storage_lock(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), lock_timestamp) + env.with_vm_hooks(|vh| vh.set_storage_lock(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), lock_timestamp)) } #[rustfmt::skip] fn wasmer_import_get_storage_lock(env: &VMHooksWrapper, key_offset: i32, key_length: i32) -> i64 { - env.vm_hooks.get_storage_lock(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length)) + env.with_vm_hooks(|vh| vh.get_storage_lock(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length))) } #[rustfmt::skip] fn wasmer_import_is_storage_locked(env: &VMHooksWrapper, key_offset: i32, key_length: i32) -> i32 { - env.vm_hooks.is_storage_locked(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length)) + env.with_vm_hooks(|vh| vh.is_storage_locked(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length))) } #[rustfmt::skip] fn wasmer_import_clear_storage_lock(env: &VMHooksWrapper, key_offset: i32, key_length: i32) -> i32 { - env.vm_hooks.clear_storage_lock(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length)) + env.with_vm_hooks(|vh| vh.clear_storage_lock(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length))) } #[rustfmt::skip] fn wasmer_import_get_caller(env: &VMHooksWrapper, result_offset: i32) { - env.vm_hooks.get_caller(env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.get_caller(env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_check_no_payment(env: &VMHooksWrapper) { - env.vm_hooks.check_no_payment() + env.with_vm_hooks(|vh| vh.check_no_payment()) } #[rustfmt::skip] fn wasmer_import_get_call_value(env: &VMHooksWrapper, result_offset: i32) -> i32 { - env.vm_hooks.get_call_value(env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.get_call_value(env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_get_esdt_value(env: &VMHooksWrapper, result_offset: i32) -> i32 { - env.vm_hooks.get_esdt_value(env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.get_esdt_value(env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_get_esdt_value_by_index(env: &VMHooksWrapper, result_offset: i32, index: i32) -> i32 { - env.vm_hooks.get_esdt_value_by_index(env.convert_mem_ptr(result_offset), index) + env.with_vm_hooks(|vh| vh.get_esdt_value_by_index(env.convert_mem_ptr(result_offset), index)) } #[rustfmt::skip] fn wasmer_import_get_esdt_token_name(env: &VMHooksWrapper, result_offset: i32) -> i32 { - env.vm_hooks.get_esdt_token_name(env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.get_esdt_token_name(env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_get_esdt_token_name_by_index(env: &VMHooksWrapper, result_offset: i32, index: i32) -> i32 { - env.vm_hooks.get_esdt_token_name_by_index(env.convert_mem_ptr(result_offset), index) + env.with_vm_hooks(|vh| vh.get_esdt_token_name_by_index(env.convert_mem_ptr(result_offset), index)) } #[rustfmt::skip] fn wasmer_import_get_esdt_token_nonce(env: &VMHooksWrapper) -> i64 { - env.vm_hooks.get_esdt_token_nonce() + env.with_vm_hooks(|vh| vh.get_esdt_token_nonce()) } #[rustfmt::skip] fn wasmer_import_get_esdt_token_nonce_by_index(env: &VMHooksWrapper, index: i32) -> i64 { - env.vm_hooks.get_esdt_token_nonce_by_index(index) + env.with_vm_hooks(|vh| vh.get_esdt_token_nonce_by_index(index)) } #[rustfmt::skip] fn wasmer_import_get_current_esdt_nft_nonce(env: &VMHooksWrapper, address_offset: i32, token_id_offset: i32, token_id_len: i32) -> i64 { - env.vm_hooks.get_current_esdt_nft_nonce(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len)) + env.with_vm_hooks(|vh| vh.get_current_esdt_nft_nonce(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len))) } #[rustfmt::skip] fn wasmer_import_get_esdt_token_type(env: &VMHooksWrapper) -> i32 { - env.vm_hooks.get_esdt_token_type() + env.with_vm_hooks(|vh| vh.get_esdt_token_type()) } #[rustfmt::skip] fn wasmer_import_get_esdt_token_type_by_index(env: &VMHooksWrapper, index: i32) -> i32 { - env.vm_hooks.get_esdt_token_type_by_index(index) + env.with_vm_hooks(|vh| vh.get_esdt_token_type_by_index(index)) } #[rustfmt::skip] fn wasmer_import_get_num_esdt_transfers(env: &VMHooksWrapper) -> i32 { - env.vm_hooks.get_num_esdt_transfers() + env.with_vm_hooks(|vh| vh.get_num_esdt_transfers()) } #[rustfmt::skip] fn wasmer_import_get_call_value_token_name(env: &VMHooksWrapper, call_value_offset: i32, token_name_offset: i32) -> i32 { - env.vm_hooks.get_call_value_token_name(env.convert_mem_ptr(call_value_offset), env.convert_mem_ptr(token_name_offset)) + env.with_vm_hooks(|vh| vh.get_call_value_token_name(env.convert_mem_ptr(call_value_offset), env.convert_mem_ptr(token_name_offset))) } #[rustfmt::skip] fn wasmer_import_get_call_value_token_name_by_index(env: &VMHooksWrapper, call_value_offset: i32, token_name_offset: i32, index: i32) -> i32 { - env.vm_hooks.get_call_value_token_name_by_index(env.convert_mem_ptr(call_value_offset), env.convert_mem_ptr(token_name_offset), index) + env.with_vm_hooks(|vh| vh.get_call_value_token_name_by_index(env.convert_mem_ptr(call_value_offset), env.convert_mem_ptr(token_name_offset), index)) } #[rustfmt::skip] fn wasmer_import_is_reserved_function_name(env: &VMHooksWrapper, name_handle: i32) -> i32 { - env.vm_hooks.is_reserved_function_name(name_handle) + env.with_vm_hooks(|vh| vh.is_reserved_function_name(name_handle)) } #[rustfmt::skip] fn wasmer_import_write_log(env: &VMHooksWrapper, data_pointer: i32, data_length: i32, topic_ptr: i32, num_topics: i32) { - env.vm_hooks.write_log(env.convert_mem_ptr(data_pointer), env.convert_mem_length(data_length), env.convert_mem_ptr(topic_ptr), num_topics) + env.with_vm_hooks(|vh| vh.write_log(env.convert_mem_ptr(data_pointer), env.convert_mem_length(data_length), env.convert_mem_ptr(topic_ptr), num_topics)) } #[rustfmt::skip] fn wasmer_import_write_event_log(env: &VMHooksWrapper, num_topics: i32, topic_lengths_offset: i32, topic_offset: i32, data_offset: i32, data_length: i32) { - env.vm_hooks.write_event_log(num_topics, env.convert_mem_ptr(topic_lengths_offset), env.convert_mem_ptr(topic_offset), env.convert_mem_ptr(data_offset), env.convert_mem_length(data_length)) + env.with_vm_hooks(|vh| vh.write_event_log(num_topics, env.convert_mem_ptr(topic_lengths_offset), env.convert_mem_ptr(topic_offset), env.convert_mem_ptr(data_offset), env.convert_mem_length(data_length))) } #[rustfmt::skip] fn wasmer_import_get_block_timestamp(env: &VMHooksWrapper) -> i64 { - env.vm_hooks.get_block_timestamp() + env.with_vm_hooks(|vh| vh.get_block_timestamp()) } #[rustfmt::skip] fn wasmer_import_get_block_nonce(env: &VMHooksWrapper) -> i64 { - env.vm_hooks.get_block_nonce() + env.with_vm_hooks(|vh| vh.get_block_nonce()) } #[rustfmt::skip] fn wasmer_import_get_block_round(env: &VMHooksWrapper) -> i64 { - env.vm_hooks.get_block_round() + env.with_vm_hooks(|vh| vh.get_block_round()) } #[rustfmt::skip] fn wasmer_import_get_block_epoch(env: &VMHooksWrapper) -> i64 { - env.vm_hooks.get_block_epoch() + env.with_vm_hooks(|vh| vh.get_block_epoch()) } #[rustfmt::skip] fn wasmer_import_get_block_random_seed(env: &VMHooksWrapper, pointer: i32) { - env.vm_hooks.get_block_random_seed(env.convert_mem_ptr(pointer)) + env.with_vm_hooks(|vh| vh.get_block_random_seed(env.convert_mem_ptr(pointer))) } #[rustfmt::skip] fn wasmer_import_get_state_root_hash(env: &VMHooksWrapper, pointer: i32) { - env.vm_hooks.get_state_root_hash(env.convert_mem_ptr(pointer)) + env.with_vm_hooks(|vh| vh.get_state_root_hash(env.convert_mem_ptr(pointer))) } #[rustfmt::skip] fn wasmer_import_get_prev_block_timestamp(env: &VMHooksWrapper) -> i64 { - env.vm_hooks.get_prev_block_timestamp() + env.with_vm_hooks(|vh| vh.get_prev_block_timestamp()) } #[rustfmt::skip] fn wasmer_import_get_prev_block_nonce(env: &VMHooksWrapper) -> i64 { - env.vm_hooks.get_prev_block_nonce() + env.with_vm_hooks(|vh| vh.get_prev_block_nonce()) } #[rustfmt::skip] fn wasmer_import_get_prev_block_round(env: &VMHooksWrapper) -> i64 { - env.vm_hooks.get_prev_block_round() + env.with_vm_hooks(|vh| vh.get_prev_block_round()) } #[rustfmt::skip] fn wasmer_import_get_prev_block_epoch(env: &VMHooksWrapper) -> i64 { - env.vm_hooks.get_prev_block_epoch() + env.with_vm_hooks(|vh| vh.get_prev_block_epoch()) } #[rustfmt::skip] fn wasmer_import_get_prev_block_random_seed(env: &VMHooksWrapper, pointer: i32) { - env.vm_hooks.get_prev_block_random_seed(env.convert_mem_ptr(pointer)) + env.with_vm_hooks(|vh| vh.get_prev_block_random_seed(env.convert_mem_ptr(pointer))) } #[rustfmt::skip] fn wasmer_import_finish(env: &VMHooksWrapper, pointer: i32, length: i32) { - env.vm_hooks.finish(env.convert_mem_ptr(pointer), env.convert_mem_length(length)) + env.with_vm_hooks(|vh| vh.finish(env.convert_mem_ptr(pointer), env.convert_mem_length(length))) } #[rustfmt::skip] fn wasmer_import_execute_on_same_context(env: &VMHooksWrapper, gas_limit: i64, address_offset: i32, value_offset: i32, function_offset: i32, function_length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> i32 { - env.vm_hooks.execute_on_same_context(gas_limit, env.convert_mem_ptr(address_offset), env.convert_mem_ptr(value_offset), env.convert_mem_ptr(function_offset), env.convert_mem_length(function_length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.execute_on_same_context(gas_limit, env.convert_mem_ptr(address_offset), env.convert_mem_ptr(value_offset), env.convert_mem_ptr(function_offset), env.convert_mem_length(function_length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_execute_on_dest_context(env: &VMHooksWrapper, gas_limit: i64, address_offset: i32, value_offset: i32, function_offset: i32, function_length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> i32 { - env.vm_hooks.execute_on_dest_context(gas_limit, env.convert_mem_ptr(address_offset), env.convert_mem_ptr(value_offset), env.convert_mem_ptr(function_offset), env.convert_mem_length(function_length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.execute_on_dest_context(gas_limit, env.convert_mem_ptr(address_offset), env.convert_mem_ptr(value_offset), env.convert_mem_ptr(function_offset), env.convert_mem_length(function_length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_execute_read_only(env: &VMHooksWrapper, gas_limit: i64, address_offset: i32, function_offset: i32, function_length: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> i32 { - env.vm_hooks.execute_read_only(gas_limit, env.convert_mem_ptr(address_offset), env.convert_mem_ptr(function_offset), env.convert_mem_length(function_length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.execute_read_only(gas_limit, env.convert_mem_ptr(address_offset), env.convert_mem_ptr(function_offset), env.convert_mem_length(function_length), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_create_contract(env: &VMHooksWrapper, gas_limit: i64, value_offset: i32, code_offset: i32, code_metadata_offset: i32, length: i32, result_offset: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> i32 { - env.vm_hooks.create_contract(gas_limit, env.convert_mem_ptr(value_offset), env.convert_mem_ptr(code_offset), env.convert_mem_ptr(code_metadata_offset), env.convert_mem_length(length), env.convert_mem_ptr(result_offset), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.create_contract(gas_limit, env.convert_mem_ptr(value_offset), env.convert_mem_ptr(code_offset), env.convert_mem_ptr(code_metadata_offset), env.convert_mem_length(length), env.convert_mem_ptr(result_offset), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_deploy_from_source_contract(env: &VMHooksWrapper, gas_limit: i64, value_offset: i32, source_contract_address_offset: i32, code_metadata_offset: i32, result_address_offset: i32, num_arguments: i32, arguments_length_offset: i32, data_offset: i32) -> i32 { - env.vm_hooks.deploy_from_source_contract(gas_limit, env.convert_mem_ptr(value_offset), env.convert_mem_ptr(source_contract_address_offset), env.convert_mem_ptr(code_metadata_offset), env.convert_mem_ptr(result_address_offset), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.deploy_from_source_contract(gas_limit, env.convert_mem_ptr(value_offset), env.convert_mem_ptr(source_contract_address_offset), env.convert_mem_ptr(code_metadata_offset), env.convert_mem_ptr(result_address_offset), num_arguments, env.convert_mem_ptr(arguments_length_offset), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_get_num_return_data(env: &VMHooksWrapper) -> i32 { - env.vm_hooks.get_num_return_data() + env.with_vm_hooks(|vh| vh.get_num_return_data()) } #[rustfmt::skip] fn wasmer_import_get_return_data_size(env: &VMHooksWrapper, result_id: i32) -> i32 { - env.vm_hooks.get_return_data_size(result_id) + env.with_vm_hooks(|vh| vh.get_return_data_size(result_id)) } #[rustfmt::skip] fn wasmer_import_get_return_data(env: &VMHooksWrapper, result_id: i32, data_offset: i32) -> i32 { - env.vm_hooks.get_return_data(result_id, env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.get_return_data(result_id, env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_clean_return_data(env: &VMHooksWrapper) { - env.vm_hooks.clean_return_data() + env.with_vm_hooks(|vh| vh.clean_return_data()) } #[rustfmt::skip] fn wasmer_import_delete_from_return_data(env: &VMHooksWrapper, result_id: i32) { - env.vm_hooks.delete_from_return_data(result_id) + env.with_vm_hooks(|vh| vh.delete_from_return_data(result_id)) } #[rustfmt::skip] fn wasmer_import_get_original_tx_hash(env: &VMHooksWrapper, data_offset: i32) { - env.vm_hooks.get_original_tx_hash(env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.get_original_tx_hash(env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_get_current_tx_hash(env: &VMHooksWrapper, data_offset: i32) { - env.vm_hooks.get_current_tx_hash(env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.get_current_tx_hash(env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_get_prev_tx_hash(env: &VMHooksWrapper, data_offset: i32) { - env.vm_hooks.get_prev_tx_hash(env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.get_prev_tx_hash(env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_managed_sc_address(env: &VMHooksWrapper, destination_handle: i32) { - env.vm_hooks.managed_sc_address(destination_handle) + env.with_vm_hooks(|vh| vh.managed_sc_address(destination_handle)) } #[rustfmt::skip] fn wasmer_import_managed_owner_address(env: &VMHooksWrapper, destination_handle: i32) { - env.vm_hooks.managed_owner_address(destination_handle) + env.with_vm_hooks(|vh| vh.managed_owner_address(destination_handle)) } #[rustfmt::skip] fn wasmer_import_managed_caller(env: &VMHooksWrapper, destination_handle: i32) { - env.vm_hooks.managed_caller(destination_handle) + env.with_vm_hooks(|vh| vh.managed_caller(destination_handle)) } #[rustfmt::skip] fn wasmer_import_managed_get_original_caller_addr(env: &VMHooksWrapper, destination_handle: i32) { - env.vm_hooks.managed_get_original_caller_addr(destination_handle) + env.with_vm_hooks(|vh| vh.managed_get_original_caller_addr(destination_handle)) } #[rustfmt::skip] fn wasmer_import_managed_get_relayer_addr(env: &VMHooksWrapper, destination_handle: i32) { - env.vm_hooks.managed_get_relayer_addr(destination_handle) + env.with_vm_hooks(|vh| vh.managed_get_relayer_addr(destination_handle)) } #[rustfmt::skip] fn wasmer_import_managed_signal_error(env: &VMHooksWrapper, err_handle: i32) { - env.vm_hooks.managed_signal_error(err_handle) + env.with_vm_hooks(|vh| vh.managed_signal_error(err_handle)) } #[rustfmt::skip] fn wasmer_import_managed_write_log(env: &VMHooksWrapper, topics_handle: i32, data_handle: i32) { - env.vm_hooks.managed_write_log(topics_handle, data_handle) + env.with_vm_hooks(|vh| vh.managed_write_log(topics_handle, data_handle)) } #[rustfmt::skip] fn wasmer_import_managed_get_original_tx_hash(env: &VMHooksWrapper, result_handle: i32) { - env.vm_hooks.managed_get_original_tx_hash(result_handle) + env.with_vm_hooks(|vh| vh.managed_get_original_tx_hash(result_handle)) } #[rustfmt::skip] fn wasmer_import_managed_get_state_root_hash(env: &VMHooksWrapper, result_handle: i32) { - env.vm_hooks.managed_get_state_root_hash(result_handle) + env.with_vm_hooks(|vh| vh.managed_get_state_root_hash(result_handle)) } #[rustfmt::skip] fn wasmer_import_managed_get_block_random_seed(env: &VMHooksWrapper, result_handle: i32) { - env.vm_hooks.managed_get_block_random_seed(result_handle) + env.with_vm_hooks(|vh| vh.managed_get_block_random_seed(result_handle)) } #[rustfmt::skip] fn wasmer_import_managed_get_prev_block_random_seed(env: &VMHooksWrapper, result_handle: i32) { - env.vm_hooks.managed_get_prev_block_random_seed(result_handle) + env.with_vm_hooks(|vh| vh.managed_get_prev_block_random_seed(result_handle)) } #[rustfmt::skip] fn wasmer_import_managed_get_return_data(env: &VMHooksWrapper, result_id: i32, result_handle: i32) { - env.vm_hooks.managed_get_return_data(result_id, result_handle) + env.with_vm_hooks(|vh| vh.managed_get_return_data(result_id, result_handle)) } #[rustfmt::skip] fn wasmer_import_managed_get_multi_esdt_call_value(env: &VMHooksWrapper, multi_call_value_handle: i32) { - env.vm_hooks.managed_get_multi_esdt_call_value(multi_call_value_handle) + env.with_vm_hooks(|vh| vh.managed_get_multi_esdt_call_value(multi_call_value_handle)) } #[rustfmt::skip] fn wasmer_import_managed_get_back_transfers(env: &VMHooksWrapper, esdt_transfers_value_handle: i32, egld_value_handle: i32) { - env.vm_hooks.managed_get_back_transfers(esdt_transfers_value_handle, egld_value_handle) + env.with_vm_hooks(|vh| vh.managed_get_back_transfers(esdt_transfers_value_handle, egld_value_handle)) } #[rustfmt::skip] fn wasmer_import_managed_get_esdt_balance(env: &VMHooksWrapper, address_handle: i32, token_id_handle: i32, nonce: i64, value_handle: i32) { - env.vm_hooks.managed_get_esdt_balance(address_handle, token_id_handle, nonce, value_handle) + env.with_vm_hooks(|vh| vh.managed_get_esdt_balance(address_handle, token_id_handle, nonce, value_handle)) } #[rustfmt::skip] fn wasmer_import_managed_get_esdt_token_data(env: &VMHooksWrapper, 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) { - env.vm_hooks.managed_get_esdt_token_data(address_handle, token_id_handle, nonce, value_handle, properties_handle, hash_handle, name_handle, attributes_handle, creator_handle, royalties_handle, uris_handle) + env.with_vm_hooks(|vh| vh.managed_get_esdt_token_data(address_handle, token_id_handle, nonce, value_handle, properties_handle, hash_handle, name_handle, attributes_handle, creator_handle, royalties_handle, uris_handle)) } #[rustfmt::skip] fn wasmer_import_managed_async_call(env: &VMHooksWrapper, dest_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32) { - env.vm_hooks.managed_async_call(dest_handle, value_handle, function_handle, arguments_handle) + env.with_vm_hooks(|vh| vh.managed_async_call(dest_handle, value_handle, function_handle, arguments_handle)) } #[rustfmt::skip] fn wasmer_import_managed_create_async_call(env: &VMHooksWrapper, dest_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, success_offset: i32, success_length: i32, error_offset: i32, error_length: i32, gas: i64, extra_gas_for_callback: i64, callback_closure_handle: i32) -> i32 { - env.vm_hooks.managed_create_async_call(dest_handle, value_handle, function_handle, arguments_handle, env.convert_mem_ptr(success_offset), env.convert_mem_length(success_length), env.convert_mem_ptr(error_offset), env.convert_mem_length(error_length), gas, extra_gas_for_callback, callback_closure_handle) + env.with_vm_hooks(|vh| vh.managed_create_async_call(dest_handle, value_handle, function_handle, arguments_handle, env.convert_mem_ptr(success_offset), env.convert_mem_length(success_length), env.convert_mem_ptr(error_offset), env.convert_mem_length(error_length), gas, extra_gas_for_callback, callback_closure_handle)) } #[rustfmt::skip] fn wasmer_import_managed_get_callback_closure(env: &VMHooksWrapper, callback_closure_handle: i32) { - env.vm_hooks.managed_get_callback_closure(callback_closure_handle) + env.with_vm_hooks(|vh| vh.managed_get_callback_closure(callback_closure_handle)) } #[rustfmt::skip] fn wasmer_import_managed_upgrade_from_source_contract(env: &VMHooksWrapper, dest_handle: i32, gas: i64, value_handle: i32, address_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_handle: i32) { - env.vm_hooks.managed_upgrade_from_source_contract(dest_handle, gas, value_handle, address_handle, code_metadata_handle, arguments_handle, result_handle) + env.with_vm_hooks(|vh| vh.managed_upgrade_from_source_contract(dest_handle, gas, value_handle, address_handle, code_metadata_handle, arguments_handle, result_handle)) } #[rustfmt::skip] fn wasmer_import_managed_upgrade_contract(env: &VMHooksWrapper, dest_handle: i32, gas: i64, value_handle: i32, code_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_handle: i32) { - env.vm_hooks.managed_upgrade_contract(dest_handle, gas, value_handle, code_handle, code_metadata_handle, arguments_handle, result_handle) + env.with_vm_hooks(|vh| vh.managed_upgrade_contract(dest_handle, gas, value_handle, code_handle, code_metadata_handle, arguments_handle, result_handle)) } #[rustfmt::skip] fn wasmer_import_managed_delete_contract(env: &VMHooksWrapper, dest_handle: i32, gas_limit: i64, arguments_handle: i32) { - env.vm_hooks.managed_delete_contract(dest_handle, gas_limit, arguments_handle) + env.with_vm_hooks(|vh| vh.managed_delete_contract(dest_handle, gas_limit, arguments_handle)) } #[rustfmt::skip] fn wasmer_import_managed_deploy_from_source_contract(env: &VMHooksWrapper, gas: i64, value_handle: i32, address_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_address_handle: i32, result_handle: i32) -> i32 { - env.vm_hooks.managed_deploy_from_source_contract(gas, value_handle, address_handle, code_metadata_handle, arguments_handle, result_address_handle, result_handle) + env.with_vm_hooks(|vh| vh.managed_deploy_from_source_contract(gas, value_handle, address_handle, code_metadata_handle, arguments_handle, result_address_handle, result_handle)) } #[rustfmt::skip] fn wasmer_import_managed_create_contract(env: &VMHooksWrapper, gas: i64, value_handle: i32, code_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_address_handle: i32, result_handle: i32) -> i32 { - env.vm_hooks.managed_create_contract(gas, value_handle, code_handle, code_metadata_handle, arguments_handle, result_address_handle, result_handle) + env.with_vm_hooks(|vh| vh.managed_create_contract(gas, value_handle, code_handle, code_metadata_handle, arguments_handle, result_address_handle, result_handle)) } #[rustfmt::skip] fn wasmer_import_managed_execute_read_only(env: &VMHooksWrapper, gas: i64, address_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32 { - env.vm_hooks.managed_execute_read_only(gas, address_handle, function_handle, arguments_handle, result_handle) + env.with_vm_hooks(|vh| vh.managed_execute_read_only(gas, address_handle, function_handle, arguments_handle, result_handle)) } #[rustfmt::skip] fn wasmer_import_managed_execute_on_same_context(env: &VMHooksWrapper, gas: i64, address_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32 { - env.vm_hooks.managed_execute_on_same_context(gas, address_handle, value_handle, function_handle, arguments_handle, result_handle) + env.with_vm_hooks(|vh| vh.managed_execute_on_same_context(gas, address_handle, value_handle, function_handle, arguments_handle, result_handle)) } #[rustfmt::skip] fn wasmer_import_managed_execute_on_dest_context(env: &VMHooksWrapper, gas: i64, address_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32 { - env.vm_hooks.managed_execute_on_dest_context(gas, address_handle, value_handle, function_handle, arguments_handle, result_handle) + env.with_vm_hooks(|vh| vh.managed_execute_on_dest_context(gas, address_handle, value_handle, function_handle, arguments_handle, result_handle)) } #[rustfmt::skip] fn wasmer_import_managed_multi_transfer_esdt_nft_execute(env: &VMHooksWrapper, dst_handle: i32, token_transfers_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32 { - env.vm_hooks.managed_multi_transfer_esdt_nft_execute(dst_handle, token_transfers_handle, gas_limit, function_handle, arguments_handle) + env.with_vm_hooks(|vh| vh.managed_multi_transfer_esdt_nft_execute(dst_handle, token_transfers_handle, gas_limit, function_handle, arguments_handle)) } #[rustfmt::skip] fn wasmer_import_managed_multi_transfer_esdt_nft_execute_by_user(env: &VMHooksWrapper, user_handle: i32, dst_handle: i32, token_transfers_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32 { - env.vm_hooks.managed_multi_transfer_esdt_nft_execute_by_user(user_handle, dst_handle, token_transfers_handle, gas_limit, function_handle, arguments_handle) + env.with_vm_hooks(|vh| vh.managed_multi_transfer_esdt_nft_execute_by_user(user_handle, dst_handle, token_transfers_handle, gas_limit, function_handle, arguments_handle)) } #[rustfmt::skip] fn wasmer_import_managed_transfer_value_execute(env: &VMHooksWrapper, dst_handle: i32, value_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32 { - env.vm_hooks.managed_transfer_value_execute(dst_handle, value_handle, gas_limit, function_handle, arguments_handle) + env.with_vm_hooks(|vh| vh.managed_transfer_value_execute(dst_handle, value_handle, gas_limit, function_handle, arguments_handle)) } #[rustfmt::skip] fn wasmer_import_managed_is_esdt_frozen(env: &VMHooksWrapper, address_handle: i32, token_id_handle: i32, nonce: i64) -> i32 { - env.vm_hooks.managed_is_esdt_frozen(address_handle, token_id_handle, nonce) + env.with_vm_hooks(|vh| vh.managed_is_esdt_frozen(address_handle, token_id_handle, nonce)) } #[rustfmt::skip] fn wasmer_import_managed_is_esdt_limited_transfer(env: &VMHooksWrapper, token_id_handle: i32) -> i32 { - env.vm_hooks.managed_is_esdt_limited_transfer(token_id_handle) + env.with_vm_hooks(|vh| vh.managed_is_esdt_limited_transfer(token_id_handle)) } #[rustfmt::skip] fn wasmer_import_managed_is_esdt_paused(env: &VMHooksWrapper, token_id_handle: i32) -> i32 { - env.vm_hooks.managed_is_esdt_paused(token_id_handle) + env.with_vm_hooks(|vh| vh.managed_is_esdt_paused(token_id_handle)) } #[rustfmt::skip] fn wasmer_import_managed_buffer_to_hex(env: &VMHooksWrapper, source_handle: i32, dest_handle: i32) { - env.vm_hooks.managed_buffer_to_hex(source_handle, dest_handle) + env.with_vm_hooks(|vh| vh.managed_buffer_to_hex(source_handle, dest_handle)) } #[rustfmt::skip] fn wasmer_import_managed_get_code_metadata(env: &VMHooksWrapper, address_handle: i32, response_handle: i32) { - env.vm_hooks.managed_get_code_metadata(address_handle, response_handle) + env.with_vm_hooks(|vh| vh.managed_get_code_metadata(address_handle, response_handle)) } #[rustfmt::skip] fn wasmer_import_managed_is_builtin_function(env: &VMHooksWrapper, function_name_handle: i32) -> i32 { - env.vm_hooks.managed_is_builtin_function(function_name_handle) + env.with_vm_hooks(|vh| vh.managed_is_builtin_function(function_name_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_new_from_parts(env: &VMHooksWrapper, integral_part: i32, fractional_part: i32, exponent: i32) -> i32 { - env.vm_hooks.big_float_new_from_parts(integral_part, fractional_part, exponent) + env.with_vm_hooks(|vh| vh.big_float_new_from_parts(integral_part, fractional_part, exponent)) } #[rustfmt::skip] fn wasmer_import_big_float_new_from_frac(env: &VMHooksWrapper, numerator: i64, denominator: i64) -> i32 { - env.vm_hooks.big_float_new_from_frac(numerator, denominator) + env.with_vm_hooks(|vh| vh.big_float_new_from_frac(numerator, denominator)) } #[rustfmt::skip] fn wasmer_import_big_float_new_from_sci(env: &VMHooksWrapper, significand: i64, exponent: i64) -> i32 { - env.vm_hooks.big_float_new_from_sci(significand, exponent) + env.with_vm_hooks(|vh| vh.big_float_new_from_sci(significand, exponent)) } #[rustfmt::skip] fn wasmer_import_big_float_add(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_float_add(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_float_add(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_sub(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_float_sub(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_float_sub(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_mul(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_float_mul(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_float_mul(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_div(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_float_div(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_float_div(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_neg(env: &VMHooksWrapper, destination_handle: i32, op_handle: i32) { - env.vm_hooks.big_float_neg(destination_handle, op_handle) + env.with_vm_hooks(|vh| vh.big_float_neg(destination_handle, op_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_clone(env: &VMHooksWrapper, destination_handle: i32, op_handle: i32) { - env.vm_hooks.big_float_clone(destination_handle, op_handle) + env.with_vm_hooks(|vh| vh.big_float_clone(destination_handle, op_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_cmp(env: &VMHooksWrapper, op1_handle: i32, op2_handle: i32) -> i32 { - env.vm_hooks.big_float_cmp(op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_float_cmp(op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_abs(env: &VMHooksWrapper, destination_handle: i32, op_handle: i32) { - env.vm_hooks.big_float_abs(destination_handle, op_handle) + env.with_vm_hooks(|vh| vh.big_float_abs(destination_handle, op_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_sign(env: &VMHooksWrapper, op_handle: i32) -> i32 { - env.vm_hooks.big_float_sign(op_handle) + env.with_vm_hooks(|vh| vh.big_float_sign(op_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_sqrt(env: &VMHooksWrapper, destination_handle: i32, op_handle: i32) { - env.vm_hooks.big_float_sqrt(destination_handle, op_handle) + env.with_vm_hooks(|vh| vh.big_float_sqrt(destination_handle, op_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_pow(env: &VMHooksWrapper, destination_handle: i32, op_handle: i32, exponent: i32) { - env.vm_hooks.big_float_pow(destination_handle, op_handle, exponent) + env.with_vm_hooks(|vh| vh.big_float_pow(destination_handle, op_handle, exponent)) } #[rustfmt::skip] fn wasmer_import_big_float_floor(env: &VMHooksWrapper, dest_big_int_handle: i32, op_handle: i32) { - env.vm_hooks.big_float_floor(dest_big_int_handle, op_handle) + env.with_vm_hooks(|vh| vh.big_float_floor(dest_big_int_handle, op_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_ceil(env: &VMHooksWrapper, dest_big_int_handle: i32, op_handle: i32) { - env.vm_hooks.big_float_ceil(dest_big_int_handle, op_handle) + env.with_vm_hooks(|vh| vh.big_float_ceil(dest_big_int_handle, op_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_truncate(env: &VMHooksWrapper, dest_big_int_handle: i32, op_handle: i32) { - env.vm_hooks.big_float_truncate(dest_big_int_handle, op_handle) + env.with_vm_hooks(|vh| vh.big_float_truncate(dest_big_int_handle, op_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_set_int64(env: &VMHooksWrapper, destination_handle: i32, value: i64) { - env.vm_hooks.big_float_set_int64(destination_handle, value) + env.with_vm_hooks(|vh| vh.big_float_set_int64(destination_handle, value)) } #[rustfmt::skip] fn wasmer_import_big_float_is_int(env: &VMHooksWrapper, op_handle: i32) -> i32 { - env.vm_hooks.big_float_is_int(op_handle) + env.with_vm_hooks(|vh| vh.big_float_is_int(op_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_set_big_int(env: &VMHooksWrapper, destination_handle: i32, big_int_handle: i32) { - env.vm_hooks.big_float_set_big_int(destination_handle, big_int_handle) + env.with_vm_hooks(|vh| vh.big_float_set_big_int(destination_handle, big_int_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_get_const_pi(env: &VMHooksWrapper, destination_handle: i32) { - env.vm_hooks.big_float_get_const_pi(destination_handle) + env.with_vm_hooks(|vh| vh.big_float_get_const_pi(destination_handle)) } #[rustfmt::skip] fn wasmer_import_big_float_get_const_e(env: &VMHooksWrapper, destination_handle: i32) { - env.vm_hooks.big_float_get_const_e(destination_handle) + env.with_vm_hooks(|vh| vh.big_float_get_const_e(destination_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_get_unsigned_argument(env: &VMHooksWrapper, id: i32, destination_handle: i32) { - env.vm_hooks.big_int_get_unsigned_argument(id, destination_handle) + env.with_vm_hooks(|vh| vh.big_int_get_unsigned_argument(id, destination_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_get_signed_argument(env: &VMHooksWrapper, id: i32, destination_handle: i32) { - env.vm_hooks.big_int_get_signed_argument(id, destination_handle) + env.with_vm_hooks(|vh| vh.big_int_get_signed_argument(id, destination_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_storage_store_unsigned(env: &VMHooksWrapper, key_offset: i32, key_length: i32, source_handle: i32) -> i32 { - env.vm_hooks.big_int_storage_store_unsigned(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), source_handle) + env.with_vm_hooks(|vh| vh.big_int_storage_store_unsigned(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), source_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_storage_load_unsigned(env: &VMHooksWrapper, key_offset: i32, key_length: i32, destination_handle: i32) -> i32 { - env.vm_hooks.big_int_storage_load_unsigned(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), destination_handle) + env.with_vm_hooks(|vh| vh.big_int_storage_load_unsigned(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), destination_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_get_call_value(env: &VMHooksWrapper, destination_handle: i32) { - env.vm_hooks.big_int_get_call_value(destination_handle) + env.with_vm_hooks(|vh| vh.big_int_get_call_value(destination_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_get_esdt_call_value(env: &VMHooksWrapper, destination: i32) { - env.vm_hooks.big_int_get_esdt_call_value(destination) + env.with_vm_hooks(|vh| vh.big_int_get_esdt_call_value(destination)) } #[rustfmt::skip] fn wasmer_import_big_int_get_esdt_call_value_by_index(env: &VMHooksWrapper, destination_handle: i32, index: i32) { - env.vm_hooks.big_int_get_esdt_call_value_by_index(destination_handle, index) + env.with_vm_hooks(|vh| vh.big_int_get_esdt_call_value_by_index(destination_handle, index)) } #[rustfmt::skip] fn wasmer_import_big_int_get_external_balance(env: &VMHooksWrapper, address_offset: i32, result: i32) { - env.vm_hooks.big_int_get_external_balance(env.convert_mem_ptr(address_offset), result) + env.with_vm_hooks(|vh| vh.big_int_get_external_balance(env.convert_mem_ptr(address_offset), result)) } #[rustfmt::skip] fn wasmer_import_big_int_get_esdt_external_balance(env: &VMHooksWrapper, address_offset: i32, token_id_offset: i32, token_id_len: i32, nonce: i64, result_handle: i32) { - env.vm_hooks.big_int_get_esdt_external_balance(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), nonce, result_handle) + env.with_vm_hooks(|vh| vh.big_int_get_esdt_external_balance(env.convert_mem_ptr(address_offset), env.convert_mem_ptr(token_id_offset), env.convert_mem_length(token_id_len), nonce, result_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_new(env: &VMHooksWrapper, small_value: i64) -> i32 { - env.vm_hooks.big_int_new(small_value) + env.with_vm_hooks(|vh| vh.big_int_new(small_value)) } #[rustfmt::skip] fn wasmer_import_big_int_unsigned_byte_length(env: &VMHooksWrapper, reference_handle: i32) -> i32 { - env.vm_hooks.big_int_unsigned_byte_length(reference_handle) + env.with_vm_hooks(|vh| vh.big_int_unsigned_byte_length(reference_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_signed_byte_length(env: &VMHooksWrapper, reference_handle: i32) -> i32 { - env.vm_hooks.big_int_signed_byte_length(reference_handle) + env.with_vm_hooks(|vh| vh.big_int_signed_byte_length(reference_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_get_unsigned_bytes(env: &VMHooksWrapper, reference_handle: i32, byte_offset: i32) -> i32 { - env.vm_hooks.big_int_get_unsigned_bytes(reference_handle, env.convert_mem_ptr(byte_offset)) + env.with_vm_hooks(|vh| vh.big_int_get_unsigned_bytes(reference_handle, env.convert_mem_ptr(byte_offset))) } #[rustfmt::skip] fn wasmer_import_big_int_get_signed_bytes(env: &VMHooksWrapper, reference_handle: i32, byte_offset: i32) -> i32 { - env.vm_hooks.big_int_get_signed_bytes(reference_handle, env.convert_mem_ptr(byte_offset)) + env.with_vm_hooks(|vh| vh.big_int_get_signed_bytes(reference_handle, env.convert_mem_ptr(byte_offset))) } #[rustfmt::skip] fn wasmer_import_big_int_set_unsigned_bytes(env: &VMHooksWrapper, destination_handle: i32, byte_offset: i32, byte_length: i32) { - env.vm_hooks.big_int_set_unsigned_bytes(destination_handle, env.convert_mem_ptr(byte_offset), env.convert_mem_length(byte_length)) + env.with_vm_hooks(|vh| vh.big_int_set_unsigned_bytes(destination_handle, env.convert_mem_ptr(byte_offset), env.convert_mem_length(byte_length))) } #[rustfmt::skip] fn wasmer_import_big_int_set_signed_bytes(env: &VMHooksWrapper, destination_handle: i32, byte_offset: i32, byte_length: i32) { - env.vm_hooks.big_int_set_signed_bytes(destination_handle, env.convert_mem_ptr(byte_offset), env.convert_mem_length(byte_length)) + env.with_vm_hooks(|vh| vh.big_int_set_signed_bytes(destination_handle, env.convert_mem_ptr(byte_offset), env.convert_mem_length(byte_length))) } #[rustfmt::skip] fn wasmer_import_big_int_is_int64(env: &VMHooksWrapper, destination_handle: i32) -> i32 { - env.vm_hooks.big_int_is_int64(destination_handle) + env.with_vm_hooks(|vh| vh.big_int_is_int64(destination_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_get_int64(env: &VMHooksWrapper, destination_handle: i32) -> i64 { - env.vm_hooks.big_int_get_int64(destination_handle) + env.with_vm_hooks(|vh| vh.big_int_get_int64(destination_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_set_int64(env: &VMHooksWrapper, destination_handle: i32, value: i64) { - env.vm_hooks.big_int_set_int64(destination_handle, value) + env.with_vm_hooks(|vh| vh.big_int_set_int64(destination_handle, value)) } #[rustfmt::skip] fn wasmer_import_big_int_add(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_int_add(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_int_add(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_sub(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_int_sub(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_int_sub(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_mul(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_int_mul(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_int_mul(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_tdiv(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_int_tdiv(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_int_tdiv(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_tmod(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_int_tmod(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_int_tmod(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_ediv(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_int_ediv(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_int_ediv(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_emod(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_int_emod(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_int_emod(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_sqrt(env: &VMHooksWrapper, destination_handle: i32, op_handle: i32) { - env.vm_hooks.big_int_sqrt(destination_handle, op_handle) + env.with_vm_hooks(|vh| vh.big_int_sqrt(destination_handle, op_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_pow(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_int_pow(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_int_pow(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_log2(env: &VMHooksWrapper, op1_handle: i32) -> i32 { - env.vm_hooks.big_int_log2(op1_handle) + env.with_vm_hooks(|vh| vh.big_int_log2(op1_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_abs(env: &VMHooksWrapper, destination_handle: i32, op_handle: i32) { - env.vm_hooks.big_int_abs(destination_handle, op_handle) + env.with_vm_hooks(|vh| vh.big_int_abs(destination_handle, op_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_neg(env: &VMHooksWrapper, destination_handle: i32, op_handle: i32) { - env.vm_hooks.big_int_neg(destination_handle, op_handle) + env.with_vm_hooks(|vh| vh.big_int_neg(destination_handle, op_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_sign(env: &VMHooksWrapper, op_handle: i32) -> i32 { - env.vm_hooks.big_int_sign(op_handle) + env.with_vm_hooks(|vh| vh.big_int_sign(op_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_cmp(env: &VMHooksWrapper, op1_handle: i32, op2_handle: i32) -> i32 { - env.vm_hooks.big_int_cmp(op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_int_cmp(op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_not(env: &VMHooksWrapper, destination_handle: i32, op_handle: i32) { - env.vm_hooks.big_int_not(destination_handle, op_handle) + env.with_vm_hooks(|vh| vh.big_int_not(destination_handle, op_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_and(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_int_and(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_int_and(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_or(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_int_or(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_int_or(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_xor(env: &VMHooksWrapper, destination_handle: i32, op1_handle: i32, op2_handle: i32) { - env.vm_hooks.big_int_xor(destination_handle, op1_handle, op2_handle) + env.with_vm_hooks(|vh| vh.big_int_xor(destination_handle, op1_handle, op2_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_shr(env: &VMHooksWrapper, destination_handle: i32, op_handle: i32, bits: i32) { - env.vm_hooks.big_int_shr(destination_handle, op_handle, bits) + env.with_vm_hooks(|vh| vh.big_int_shr(destination_handle, op_handle, bits)) } #[rustfmt::skip] fn wasmer_import_big_int_shl(env: &VMHooksWrapper, destination_handle: i32, op_handle: i32, bits: i32) { - env.vm_hooks.big_int_shl(destination_handle, op_handle, bits) + env.with_vm_hooks(|vh| vh.big_int_shl(destination_handle, op_handle, bits)) } #[rustfmt::skip] fn wasmer_import_big_int_finish_unsigned(env: &VMHooksWrapper, reference_handle: i32) { - env.vm_hooks.big_int_finish_unsigned(reference_handle) + env.with_vm_hooks(|vh| vh.big_int_finish_unsigned(reference_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_finish_signed(env: &VMHooksWrapper, reference_handle: i32) { - env.vm_hooks.big_int_finish_signed(reference_handle) + env.with_vm_hooks(|vh| vh.big_int_finish_signed(reference_handle)) } #[rustfmt::skip] fn wasmer_import_big_int_to_string(env: &VMHooksWrapper, big_int_handle: i32, destination_handle: i32) { - env.vm_hooks.big_int_to_string(big_int_handle, destination_handle) + env.with_vm_hooks(|vh| vh.big_int_to_string(big_int_handle, destination_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_new(env: &VMHooksWrapper) -> i32 { - env.vm_hooks.mbuffer_new() + env.with_vm_hooks(|vh| vh.mbuffer_new()) } #[rustfmt::skip] fn wasmer_import_mbuffer_new_from_bytes(env: &VMHooksWrapper, data_offset: i32, data_length: i32) -> i32 { - env.vm_hooks.mbuffer_new_from_bytes(env.convert_mem_ptr(data_offset), env.convert_mem_length(data_length)) + env.with_vm_hooks(|vh| vh.mbuffer_new_from_bytes(env.convert_mem_ptr(data_offset), env.convert_mem_length(data_length))) } #[rustfmt::skip] fn wasmer_import_mbuffer_get_length(env: &VMHooksWrapper, m_buffer_handle: i32) -> i32 { - env.vm_hooks.mbuffer_get_length(m_buffer_handle) + env.with_vm_hooks(|vh| vh.mbuffer_get_length(m_buffer_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_get_bytes(env: &VMHooksWrapper, m_buffer_handle: i32, result_offset: i32) -> i32 { - env.vm_hooks.mbuffer_get_bytes(m_buffer_handle, env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.mbuffer_get_bytes(m_buffer_handle, env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_mbuffer_get_byte_slice(env: &VMHooksWrapper, source_handle: i32, starting_position: i32, slice_length: i32, result_offset: i32) -> i32 { - env.vm_hooks.mbuffer_get_byte_slice(source_handle, starting_position, slice_length, env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.mbuffer_get_byte_slice(source_handle, starting_position, slice_length, env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_mbuffer_copy_byte_slice(env: &VMHooksWrapper, source_handle: i32, starting_position: i32, slice_length: i32, destination_handle: i32) -> i32 { - env.vm_hooks.mbuffer_copy_byte_slice(source_handle, starting_position, slice_length, destination_handle) + env.with_vm_hooks(|vh| vh.mbuffer_copy_byte_slice(source_handle, starting_position, slice_length, destination_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_eq(env: &VMHooksWrapper, m_buffer_handle1: i32, m_buffer_handle2: i32) -> i32 { - env.vm_hooks.mbuffer_eq(m_buffer_handle1, m_buffer_handle2) + env.with_vm_hooks(|vh| vh.mbuffer_eq(m_buffer_handle1, m_buffer_handle2)) } #[rustfmt::skip] fn wasmer_import_mbuffer_set_bytes(env: &VMHooksWrapper, m_buffer_handle: i32, data_offset: i32, data_length: i32) -> i32 { - env.vm_hooks.mbuffer_set_bytes(m_buffer_handle, env.convert_mem_ptr(data_offset), env.convert_mem_length(data_length)) + env.with_vm_hooks(|vh| vh.mbuffer_set_bytes(m_buffer_handle, env.convert_mem_ptr(data_offset), env.convert_mem_length(data_length))) } #[rustfmt::skip] fn wasmer_import_mbuffer_set_byte_slice(env: &VMHooksWrapper, m_buffer_handle: i32, starting_position: i32, data_length: i32, data_offset: i32) -> i32 { - env.vm_hooks.mbuffer_set_byte_slice(m_buffer_handle, starting_position, env.convert_mem_length(data_length), env.convert_mem_ptr(data_offset)) + env.with_vm_hooks(|vh| vh.mbuffer_set_byte_slice(m_buffer_handle, starting_position, env.convert_mem_length(data_length), env.convert_mem_ptr(data_offset))) } #[rustfmt::skip] fn wasmer_import_mbuffer_append(env: &VMHooksWrapper, accumulator_handle: i32, data_handle: i32) -> i32 { - env.vm_hooks.mbuffer_append(accumulator_handle, data_handle) + env.with_vm_hooks(|vh| vh.mbuffer_append(accumulator_handle, data_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_append_bytes(env: &VMHooksWrapper, accumulator_handle: i32, data_offset: i32, data_length: i32) -> i32 { - env.vm_hooks.mbuffer_append_bytes(accumulator_handle, env.convert_mem_ptr(data_offset), env.convert_mem_length(data_length)) + env.with_vm_hooks(|vh| vh.mbuffer_append_bytes(accumulator_handle, env.convert_mem_ptr(data_offset), env.convert_mem_length(data_length))) } #[rustfmt::skip] fn wasmer_import_mbuffer_to_big_int_unsigned(env: &VMHooksWrapper, m_buffer_handle: i32, big_int_handle: i32) -> i32 { - env.vm_hooks.mbuffer_to_big_int_unsigned(m_buffer_handle, big_int_handle) + env.with_vm_hooks(|vh| vh.mbuffer_to_big_int_unsigned(m_buffer_handle, big_int_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_to_big_int_signed(env: &VMHooksWrapper, m_buffer_handle: i32, big_int_handle: i32) -> i32 { - env.vm_hooks.mbuffer_to_big_int_signed(m_buffer_handle, big_int_handle) + env.with_vm_hooks(|vh| vh.mbuffer_to_big_int_signed(m_buffer_handle, big_int_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_from_big_int_unsigned(env: &VMHooksWrapper, m_buffer_handle: i32, big_int_handle: i32) -> i32 { - env.vm_hooks.mbuffer_from_big_int_unsigned(m_buffer_handle, big_int_handle) + env.with_vm_hooks(|vh| vh.mbuffer_from_big_int_unsigned(m_buffer_handle, big_int_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_from_big_int_signed(env: &VMHooksWrapper, m_buffer_handle: i32, big_int_handle: i32) -> i32 { - env.vm_hooks.mbuffer_from_big_int_signed(m_buffer_handle, big_int_handle) + env.with_vm_hooks(|vh| vh.mbuffer_from_big_int_signed(m_buffer_handle, big_int_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_to_big_float(env: &VMHooksWrapper, m_buffer_handle: i32, big_float_handle: i32) -> i32 { - env.vm_hooks.mbuffer_to_big_float(m_buffer_handle, big_float_handle) + env.with_vm_hooks(|vh| vh.mbuffer_to_big_float(m_buffer_handle, big_float_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_from_big_float(env: &VMHooksWrapper, m_buffer_handle: i32, big_float_handle: i32) -> i32 { - env.vm_hooks.mbuffer_from_big_float(m_buffer_handle, big_float_handle) + env.with_vm_hooks(|vh| vh.mbuffer_from_big_float(m_buffer_handle, big_float_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_storage_store(env: &VMHooksWrapper, key_handle: i32, source_handle: i32) -> i32 { - env.vm_hooks.mbuffer_storage_store(key_handle, source_handle) + env.with_vm_hooks(|vh| vh.mbuffer_storage_store(key_handle, source_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_storage_load(env: &VMHooksWrapper, key_handle: i32, destination_handle: i32) -> i32 { - env.vm_hooks.mbuffer_storage_load(key_handle, destination_handle) + env.with_vm_hooks(|vh| vh.mbuffer_storage_load(key_handle, destination_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_storage_load_from_address(env: &VMHooksWrapper, address_handle: i32, key_handle: i32, destination_handle: i32) { - env.vm_hooks.mbuffer_storage_load_from_address(address_handle, key_handle, destination_handle) + env.with_vm_hooks(|vh| vh.mbuffer_storage_load_from_address(address_handle, key_handle, destination_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_get_argument(env: &VMHooksWrapper, id: i32, destination_handle: i32) -> i32 { - env.vm_hooks.mbuffer_get_argument(id, destination_handle) + env.with_vm_hooks(|vh| vh.mbuffer_get_argument(id, destination_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_finish(env: &VMHooksWrapper, source_handle: i32) -> i32 { - env.vm_hooks.mbuffer_finish(source_handle) + env.with_vm_hooks(|vh| vh.mbuffer_finish(source_handle)) } #[rustfmt::skip] fn wasmer_import_mbuffer_set_random(env: &VMHooksWrapper, destination_handle: i32, length: i32) -> i32 { - env.vm_hooks.mbuffer_set_random(destination_handle, length) + env.with_vm_hooks(|vh| vh.mbuffer_set_random(destination_handle, length)) } #[rustfmt::skip] fn wasmer_import_managed_map_new(env: &VMHooksWrapper) -> i32 { - env.vm_hooks.managed_map_new() + env.with_vm_hooks(|vh| vh.managed_map_new()) } #[rustfmt::skip] fn wasmer_import_managed_map_put(env: &VMHooksWrapper, m_map_handle: i32, key_handle: i32, value_handle: i32) -> i32 { - env.vm_hooks.managed_map_put(m_map_handle, key_handle, value_handle) + env.with_vm_hooks(|vh| vh.managed_map_put(m_map_handle, key_handle, value_handle)) } #[rustfmt::skip] fn wasmer_import_managed_map_get(env: &VMHooksWrapper, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> i32 { - env.vm_hooks.managed_map_get(m_map_handle, key_handle, out_value_handle) + env.with_vm_hooks(|vh| vh.managed_map_get(m_map_handle, key_handle, out_value_handle)) } #[rustfmt::skip] fn wasmer_import_managed_map_remove(env: &VMHooksWrapper, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> i32 { - env.vm_hooks.managed_map_remove(m_map_handle, key_handle, out_value_handle) + env.with_vm_hooks(|vh| vh.managed_map_remove(m_map_handle, key_handle, out_value_handle)) } #[rustfmt::skip] fn wasmer_import_managed_map_contains(env: &VMHooksWrapper, m_map_handle: i32, key_handle: i32) -> i32 { - env.vm_hooks.managed_map_contains(m_map_handle, key_handle) + env.with_vm_hooks(|vh| vh.managed_map_contains(m_map_handle, key_handle)) } #[rustfmt::skip] fn wasmer_import_small_int_get_unsigned_argument(env: &VMHooksWrapper, id: i32) -> i64 { - env.vm_hooks.small_int_get_unsigned_argument(id) + env.with_vm_hooks(|vh| vh.small_int_get_unsigned_argument(id)) } #[rustfmt::skip] fn wasmer_import_small_int_get_signed_argument(env: &VMHooksWrapper, id: i32) -> i64 { - env.vm_hooks.small_int_get_signed_argument(id) + env.with_vm_hooks(|vh| vh.small_int_get_signed_argument(id)) } #[rustfmt::skip] fn wasmer_import_small_int_finish_unsigned(env: &VMHooksWrapper, value: i64) { - env.vm_hooks.small_int_finish_unsigned(value) + env.with_vm_hooks(|vh| vh.small_int_finish_unsigned(value)) } #[rustfmt::skip] fn wasmer_import_small_int_finish_signed(env: &VMHooksWrapper, value: i64) { - env.vm_hooks.small_int_finish_signed(value) + env.with_vm_hooks(|vh| vh.small_int_finish_signed(value)) } #[rustfmt::skip] fn wasmer_import_small_int_storage_store_unsigned(env: &VMHooksWrapper, key_offset: i32, key_length: i32, value: i64) -> i32 { - env.vm_hooks.small_int_storage_store_unsigned(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), value) + env.with_vm_hooks(|vh| vh.small_int_storage_store_unsigned(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), value)) } #[rustfmt::skip] fn wasmer_import_small_int_storage_store_signed(env: &VMHooksWrapper, key_offset: i32, key_length: i32, value: i64) -> i32 { - env.vm_hooks.small_int_storage_store_signed(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), value) + env.with_vm_hooks(|vh| vh.small_int_storage_store_signed(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), value)) } #[rustfmt::skip] fn wasmer_import_small_int_storage_load_unsigned(env: &VMHooksWrapper, key_offset: i32, key_length: i32) -> i64 { - env.vm_hooks.small_int_storage_load_unsigned(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length)) + env.with_vm_hooks(|vh| vh.small_int_storage_load_unsigned(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length))) } #[rustfmt::skip] fn wasmer_import_small_int_storage_load_signed(env: &VMHooksWrapper, key_offset: i32, key_length: i32) -> i64 { - env.vm_hooks.small_int_storage_load_signed(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length)) + env.with_vm_hooks(|vh| vh.small_int_storage_load_signed(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length))) } #[rustfmt::skip] fn wasmer_import_int64get_argument(env: &VMHooksWrapper, id: i32) -> i64 { - env.vm_hooks.int64get_argument(id) + env.with_vm_hooks(|vh| vh.int64get_argument(id)) } #[rustfmt::skip] fn wasmer_import_int64finish(env: &VMHooksWrapper, value: i64) { - env.vm_hooks.int64finish(value) + env.with_vm_hooks(|vh| vh.int64finish(value)) } #[rustfmt::skip] fn wasmer_import_int64storage_store(env: &VMHooksWrapper, key_offset: i32, key_length: i32, value: i64) -> i32 { - env.vm_hooks.int64storage_store(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), value) + env.with_vm_hooks(|vh| vh.int64storage_store(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), value)) } #[rustfmt::skip] fn wasmer_import_int64storage_load(env: &VMHooksWrapper, key_offset: i32, key_length: i32) -> i64 { - env.vm_hooks.int64storage_load(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length)) + env.with_vm_hooks(|vh| vh.int64storage_load(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length))) } #[rustfmt::skip] fn wasmer_import_sha256(env: &VMHooksWrapper, data_offset: i32, length: i32, result_offset: i32) -> i32 { - env.vm_hooks.sha256(env.convert_mem_ptr(data_offset), env.convert_mem_length(length), env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.sha256(env.convert_mem_ptr(data_offset), env.convert_mem_length(length), env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_managed_sha256(env: &VMHooksWrapper, input_handle: i32, output_handle: i32) -> i32 { - env.vm_hooks.managed_sha256(input_handle, output_handle) + env.with_vm_hooks(|vh| vh.managed_sha256(input_handle, output_handle)) } #[rustfmt::skip] fn wasmer_import_keccak256(env: &VMHooksWrapper, data_offset: i32, length: i32, result_offset: i32) -> i32 { - env.vm_hooks.keccak256(env.convert_mem_ptr(data_offset), env.convert_mem_length(length), env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.keccak256(env.convert_mem_ptr(data_offset), env.convert_mem_length(length), env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_managed_keccak256(env: &VMHooksWrapper, input_handle: i32, output_handle: i32) -> i32 { - env.vm_hooks.managed_keccak256(input_handle, output_handle) + env.with_vm_hooks(|vh| vh.managed_keccak256(input_handle, output_handle)) } #[rustfmt::skip] fn wasmer_import_ripemd160(env: &VMHooksWrapper, data_offset: i32, length: i32, result_offset: i32) -> i32 { - env.vm_hooks.ripemd160(env.convert_mem_ptr(data_offset), env.convert_mem_length(length), env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.ripemd160(env.convert_mem_ptr(data_offset), env.convert_mem_length(length), env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_managed_ripemd160(env: &VMHooksWrapper, input_handle: i32, output_handle: i32) -> i32 { - env.vm_hooks.managed_ripemd160(input_handle, output_handle) + env.with_vm_hooks(|vh| vh.managed_ripemd160(input_handle, output_handle)) } #[rustfmt::skip] fn wasmer_import_verify_bls(env: &VMHooksWrapper, key_offset: i32, message_offset: i32, message_length: i32, sig_offset: i32) -> i32 { - env.vm_hooks.verify_bls(env.convert_mem_ptr(key_offset), env.convert_mem_ptr(message_offset), env.convert_mem_length(message_length), env.convert_mem_ptr(sig_offset)) + env.with_vm_hooks(|vh| vh.verify_bls(env.convert_mem_ptr(key_offset), env.convert_mem_ptr(message_offset), env.convert_mem_length(message_length), env.convert_mem_ptr(sig_offset))) } #[rustfmt::skip] fn wasmer_import_managed_verify_bls(env: &VMHooksWrapper, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { - env.vm_hooks.managed_verify_bls(key_handle, message_handle, sig_handle) + env.with_vm_hooks(|vh| vh.managed_verify_bls(key_handle, message_handle, sig_handle)) } #[rustfmt::skip] fn wasmer_import_verify_ed25519(env: &VMHooksWrapper, key_offset: i32, message_offset: i32, message_length: i32, sig_offset: i32) -> i32 { - env.vm_hooks.verify_ed25519(env.convert_mem_ptr(key_offset), env.convert_mem_ptr(message_offset), env.convert_mem_length(message_length), env.convert_mem_ptr(sig_offset)) + env.with_vm_hooks(|vh| vh.verify_ed25519(env.convert_mem_ptr(key_offset), env.convert_mem_ptr(message_offset), env.convert_mem_length(message_length), env.convert_mem_ptr(sig_offset))) } #[rustfmt::skip] fn wasmer_import_managed_verify_ed25519(env: &VMHooksWrapper, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { - env.vm_hooks.managed_verify_ed25519(key_handle, message_handle, sig_handle) + env.with_vm_hooks(|vh| vh.managed_verify_ed25519(key_handle, message_handle, sig_handle)) } #[rustfmt::skip] fn wasmer_import_verify_custom_secp256k1(env: &VMHooksWrapper, key_offset: i32, key_length: i32, message_offset: i32, message_length: i32, sig_offset: i32, hash_type: i32) -> i32 { - env.vm_hooks.verify_custom_secp256k1(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), env.convert_mem_ptr(message_offset), env.convert_mem_length(message_length), env.convert_mem_ptr(sig_offset), hash_type) + env.with_vm_hooks(|vh| vh.verify_custom_secp256k1(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), env.convert_mem_ptr(message_offset), env.convert_mem_length(message_length), env.convert_mem_ptr(sig_offset), hash_type)) } #[rustfmt::skip] fn wasmer_import_managed_verify_custom_secp256k1(env: &VMHooksWrapper, key_handle: i32, message_handle: i32, sig_handle: i32, hash_type: i32) -> i32 { - env.vm_hooks.managed_verify_custom_secp256k1(key_handle, message_handle, sig_handle, hash_type) + env.with_vm_hooks(|vh| vh.managed_verify_custom_secp256k1(key_handle, message_handle, sig_handle, hash_type)) } #[rustfmt::skip] fn wasmer_import_verify_secp256k1(env: &VMHooksWrapper, key_offset: i32, key_length: i32, message_offset: i32, message_length: i32, sig_offset: i32) -> i32 { - env.vm_hooks.verify_secp256k1(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), env.convert_mem_ptr(message_offset), env.convert_mem_length(message_length), env.convert_mem_ptr(sig_offset)) + env.with_vm_hooks(|vh| vh.verify_secp256k1(env.convert_mem_ptr(key_offset), env.convert_mem_length(key_length), env.convert_mem_ptr(message_offset), env.convert_mem_length(message_length), env.convert_mem_ptr(sig_offset))) } #[rustfmt::skip] fn wasmer_import_managed_verify_secp256k1(env: &VMHooksWrapper, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { - env.vm_hooks.managed_verify_secp256k1(key_handle, message_handle, sig_handle) + env.with_vm_hooks(|vh| vh.managed_verify_secp256k1(key_handle, message_handle, sig_handle)) } #[rustfmt::skip] fn wasmer_import_encode_secp256k1_der_signature(env: &VMHooksWrapper, r_offset: i32, r_length: i32, s_offset: i32, s_length: i32, sig_offset: i32) -> i32 { - env.vm_hooks.encode_secp256k1_der_signature(env.convert_mem_ptr(r_offset), env.convert_mem_length(r_length), env.convert_mem_ptr(s_offset), env.convert_mem_length(s_length), env.convert_mem_ptr(sig_offset)) + env.with_vm_hooks(|vh| vh.encode_secp256k1_der_signature(env.convert_mem_ptr(r_offset), env.convert_mem_length(r_length), env.convert_mem_ptr(s_offset), env.convert_mem_length(s_length), env.convert_mem_ptr(sig_offset))) } #[rustfmt::skip] fn wasmer_import_managed_encode_secp256k1_der_signature(env: &VMHooksWrapper, r_handle: i32, s_handle: i32, sig_handle: i32) -> i32 { - env.vm_hooks.managed_encode_secp256k1_der_signature(r_handle, s_handle, sig_handle) + env.with_vm_hooks(|vh| vh.managed_encode_secp256k1_der_signature(r_handle, s_handle, sig_handle)) } #[rustfmt::skip] fn wasmer_import_add_ec(env: &VMHooksWrapper, 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) { - env.vm_hooks.add_ec(x_result_handle, y_result_handle, ec_handle, fst_point_xhandle, fst_point_yhandle, snd_point_xhandle, snd_point_yhandle) + env.with_vm_hooks(|vh| vh.add_ec(x_result_handle, y_result_handle, ec_handle, fst_point_xhandle, fst_point_yhandle, snd_point_xhandle, snd_point_yhandle)) } #[rustfmt::skip] fn wasmer_import_double_ec(env: &VMHooksWrapper, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) { - env.vm_hooks.double_ec(x_result_handle, y_result_handle, ec_handle, point_xhandle, point_yhandle) + env.with_vm_hooks(|vh| vh.double_ec(x_result_handle, y_result_handle, ec_handle, point_xhandle, point_yhandle)) } #[rustfmt::skip] fn wasmer_import_is_on_curve_ec(env: &VMHooksWrapper, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) -> i32 { - env.vm_hooks.is_on_curve_ec(ec_handle, point_xhandle, point_yhandle) + env.with_vm_hooks(|vh| vh.is_on_curve_ec(ec_handle, point_xhandle, point_yhandle)) } #[rustfmt::skip] fn wasmer_import_scalar_base_mult_ec(env: &VMHooksWrapper, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: i32, length: i32) -> i32 { - env.vm_hooks.scalar_base_mult_ec(x_result_handle, y_result_handle, ec_handle, env.convert_mem_ptr(data_offset), env.convert_mem_length(length)) + env.with_vm_hooks(|vh| vh.scalar_base_mult_ec(x_result_handle, y_result_handle, ec_handle, env.convert_mem_ptr(data_offset), env.convert_mem_length(length))) } #[rustfmt::skip] fn wasmer_import_managed_scalar_base_mult_ec(env: &VMHooksWrapper, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { - env.vm_hooks.managed_scalar_base_mult_ec(x_result_handle, y_result_handle, ec_handle, data_handle) + env.with_vm_hooks(|vh| vh.managed_scalar_base_mult_ec(x_result_handle, y_result_handle, ec_handle, data_handle)) } #[rustfmt::skip] fn wasmer_import_scalar_mult_ec(env: &VMHooksWrapper, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32, data_offset: i32, length: i32) -> i32 { - env.vm_hooks.scalar_mult_ec(x_result_handle, y_result_handle, ec_handle, point_xhandle, point_yhandle, env.convert_mem_ptr(data_offset), env.convert_mem_length(length)) + env.with_vm_hooks(|vh| vh.scalar_mult_ec(x_result_handle, y_result_handle, ec_handle, point_xhandle, point_yhandle, env.convert_mem_ptr(data_offset), env.convert_mem_length(length))) } #[rustfmt::skip] fn wasmer_import_managed_scalar_mult_ec(env: &VMHooksWrapper, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32, data_handle: i32) -> i32 { - env.vm_hooks.managed_scalar_mult_ec(x_result_handle, y_result_handle, ec_handle, point_xhandle, point_yhandle, data_handle) + env.with_vm_hooks(|vh| vh.managed_scalar_mult_ec(x_result_handle, y_result_handle, ec_handle, point_xhandle, point_yhandle, data_handle)) } #[rustfmt::skip] fn wasmer_import_marshal_ec(env: &VMHooksWrapper, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: i32) -> i32 { - env.vm_hooks.marshal_ec(x_pair_handle, y_pair_handle, ec_handle, env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.marshal_ec(x_pair_handle, y_pair_handle, ec_handle, env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_managed_marshal_ec(env: &VMHooksWrapper, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { - env.vm_hooks.managed_marshal_ec(x_pair_handle, y_pair_handle, ec_handle, result_handle) + env.with_vm_hooks(|vh| vh.managed_marshal_ec(x_pair_handle, y_pair_handle, ec_handle, result_handle)) } #[rustfmt::skip] fn wasmer_import_marshal_compressed_ec(env: &VMHooksWrapper, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: i32) -> i32 { - env.vm_hooks.marshal_compressed_ec(x_pair_handle, y_pair_handle, ec_handle, env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.marshal_compressed_ec(x_pair_handle, y_pair_handle, ec_handle, env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_managed_marshal_compressed_ec(env: &VMHooksWrapper, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { - env.vm_hooks.managed_marshal_compressed_ec(x_pair_handle, y_pair_handle, ec_handle, result_handle) + env.with_vm_hooks(|vh| vh.managed_marshal_compressed_ec(x_pair_handle, y_pair_handle, ec_handle, result_handle)) } #[rustfmt::skip] fn wasmer_import_unmarshal_ec(env: &VMHooksWrapper, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: i32, length: i32) -> i32 { - env.vm_hooks.unmarshal_ec(x_result_handle, y_result_handle, ec_handle, env.convert_mem_ptr(data_offset), env.convert_mem_length(length)) + env.with_vm_hooks(|vh| vh.unmarshal_ec(x_result_handle, y_result_handle, ec_handle, env.convert_mem_ptr(data_offset), env.convert_mem_length(length))) } #[rustfmt::skip] fn wasmer_import_managed_unmarshal_ec(env: &VMHooksWrapper, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { - env.vm_hooks.managed_unmarshal_ec(x_result_handle, y_result_handle, ec_handle, data_handle) + env.with_vm_hooks(|vh| vh.managed_unmarshal_ec(x_result_handle, y_result_handle, ec_handle, data_handle)) } #[rustfmt::skip] fn wasmer_import_unmarshal_compressed_ec(env: &VMHooksWrapper, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: i32, length: i32) -> i32 { - env.vm_hooks.unmarshal_compressed_ec(x_result_handle, y_result_handle, ec_handle, env.convert_mem_ptr(data_offset), env.convert_mem_length(length)) + env.with_vm_hooks(|vh| vh.unmarshal_compressed_ec(x_result_handle, y_result_handle, ec_handle, env.convert_mem_ptr(data_offset), env.convert_mem_length(length))) } #[rustfmt::skip] fn wasmer_import_managed_unmarshal_compressed_ec(env: &VMHooksWrapper, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { - env.vm_hooks.managed_unmarshal_compressed_ec(x_result_handle, y_result_handle, ec_handle, data_handle) + env.with_vm_hooks(|vh| vh.managed_unmarshal_compressed_ec(x_result_handle, y_result_handle, ec_handle, data_handle)) } #[rustfmt::skip] fn wasmer_import_generate_key_ec(env: &VMHooksWrapper, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_offset: i32) -> i32 { - env.vm_hooks.generate_key_ec(x_pub_key_handle, y_pub_key_handle, ec_handle, env.convert_mem_ptr(result_offset)) + env.with_vm_hooks(|vh| vh.generate_key_ec(x_pub_key_handle, y_pub_key_handle, ec_handle, env.convert_mem_ptr(result_offset))) } #[rustfmt::skip] fn wasmer_import_managed_generate_key_ec(env: &VMHooksWrapper, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { - env.vm_hooks.managed_generate_key_ec(x_pub_key_handle, y_pub_key_handle, ec_handle, result_handle) + env.with_vm_hooks(|vh| vh.managed_generate_key_ec(x_pub_key_handle, y_pub_key_handle, ec_handle, result_handle)) } #[rustfmt::skip] fn wasmer_import_create_ec(env: &VMHooksWrapper, data_offset: i32, data_length: i32) -> i32 { - env.vm_hooks.create_ec(env.convert_mem_ptr(data_offset), env.convert_mem_length(data_length)) + env.with_vm_hooks(|vh| vh.create_ec(env.convert_mem_ptr(data_offset), env.convert_mem_length(data_length))) } #[rustfmt::skip] fn wasmer_import_managed_create_ec(env: &VMHooksWrapper, data_handle: i32) -> i32 { - env.vm_hooks.managed_create_ec(data_handle) + env.with_vm_hooks(|vh| vh.managed_create_ec(data_handle)) } #[rustfmt::skip] fn wasmer_import_get_curve_length_ec(env: &VMHooksWrapper, ec_handle: i32) -> i32 { - env.vm_hooks.get_curve_length_ec(ec_handle) + env.with_vm_hooks(|vh| vh.get_curve_length_ec(ec_handle)) } #[rustfmt::skip] fn wasmer_import_get_priv_key_byte_length_ec(env: &VMHooksWrapper, ec_handle: i32) -> i32 { - env.vm_hooks.get_priv_key_byte_length_ec(ec_handle) + env.with_vm_hooks(|vh| vh.get_priv_key_byte_length_ec(ec_handle)) } #[rustfmt::skip] fn wasmer_import_elliptic_curve_get_values(env: &VMHooksWrapper, 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) -> i32 { - env.vm_hooks.elliptic_curve_get_values(ec_handle, field_order_handle, base_point_order_handle, eq_constant_handle, x_base_point_handle, y_base_point_handle) + env.with_vm_hooks(|vh| vh.elliptic_curve_get_values(ec_handle, field_order_handle, base_point_order_handle, eq_constant_handle, x_base_point_handle, y_base_point_handle)) } #[rustfmt::skip] fn wasmer_import_managed_verify_secp256r1(env: &VMHooksWrapper, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { - env.vm_hooks.managed_verify_secp256r1(key_handle, message_handle, sig_handle) + env.with_vm_hooks(|vh| vh.managed_verify_secp256r1(key_handle, message_handle, sig_handle)) } #[rustfmt::skip] fn wasmer_import_managed_verify_blssignature_share(env: &VMHooksWrapper, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { - env.vm_hooks.managed_verify_blssignature_share(key_handle, message_handle, sig_handle) + env.with_vm_hooks(|vh| vh.managed_verify_blssignature_share(key_handle, message_handle, sig_handle)) } #[rustfmt::skip] fn wasmer_import_managed_verify_blsaggregated_signature(env: &VMHooksWrapper, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { - env.vm_hooks.managed_verify_blsaggregated_signature(key_handle, message_handle, sig_handle) + env.with_vm_hooks(|vh| vh.managed_verify_blsaggregated_signature(key_handle, message_handle, sig_handle)) } pub fn generate_import_object(store: &Store, env: &VMHooksWrapper) -> ImportObject { diff --git a/vm-executor-wasmer/src/wasmer_instance.rs b/vm-executor-wasmer/src/wasmer_instance.rs index 49acbbb..89d4411 100644 --- a/vm-executor-wasmer/src/wasmer_instance.rs +++ b/vm-executor-wasmer/src/wasmer_instance.rs @@ -2,15 +2,17 @@ use crate::wasmer_opcode_trace::OpcodeTracer; use crate::wasmer_protected_globals::ProtectedGlobals; use crate::{ wasmer_breakpoints::*, wasmer_imports::generate_import_object, wasmer_metering::*, - wasmer_opcode_control::OpcodeControl, wasmer_vm_hooks::VMHooksWrapper, WasmerExecutorData, + wasmer_opcode_control::OpcodeControl, wasmer_vm_hooks::VMHooksWrapper, }; use log::trace; use multiversx_chain_vm_executor::{ - BreakpointValue, CompilationOptions, ExecutorError, Instance, ServiceError, + BreakpointValue, CompilationOptions, ExecutorError, InstanceLegacy, OpcodeCost, ServiceError, + VMHooksLegacy, }; use multiversx_chain_vm_executor::{MemLength, MemPtr}; use std::cell::RefCell; +use std::sync::Mutex; use std::{rc::Rc, sync::Arc}; use wasmer::Universal; use wasmer::{CompilerConfig, Extern, Module, Store}; @@ -24,16 +26,17 @@ pub struct WasmerInstance { } impl WasmerInstance { - pub(crate) fn try_new_instance( - executor_data: Rc>, + pub fn try_new_instance( + vm_hooks: Rc>>, + opcode_cost: Arc>, wasm_bytes: &[u8], compilation_options: &CompilationOptions, - ) -> Result, ExecutorError> { + ) -> Result { // Use Singlepass compiler with the default settings let mut compiler = Singlepass::default(); // Push middlewares - push_middlewares(&mut compiler, compilation_options, executor_data.clone()); + push_middlewares(&mut compiler, compilation_options, opcode_cost); // Create the store let store = Store::new(&Universal::new(compiler).engine()); @@ -43,9 +46,7 @@ impl WasmerInstance { // Create an empty import object. trace!("Generating imports ..."); - let vm_hooks_wrapper = VMHooksWrapper { - vm_hooks: executor_data.borrow().get_vm_hooks(), - }; + let vm_hooks_wrapper = VMHooksWrapper { vm_hooks }; let import_object = generate_import_object(&store, &vm_hooks_wrapper); trace!("Instantiating WasmerInstance ..."); @@ -64,22 +65,23 @@ impl WasmerInstance { trace!("WasmerMemory size: {:#?}", memory.size()); let memory_name = memories[0].0.clone(); - Ok(Box::new(WasmerInstance { + Ok(WasmerInstance { wasmer_instance, memory_name, - })) + }) } - pub(crate) fn try_new_instance_from_cache( - executor_data: Rc>, + pub fn try_new_instance_from_cache( + vm_hooks: Rc>>, + opcode_cost: Arc>, cache_bytes: &[u8], compilation_options: &CompilationOptions, - ) -> Result, ExecutorError> { + ) -> Result { // Use Singlepass compiler with the default settings let mut compiler = Singlepass::default(); // Push middlewares - push_middlewares(&mut compiler, compilation_options, executor_data.clone()); + push_middlewares(&mut compiler, compilation_options, opcode_cost); // Create the store let store = Store::new(&Universal::new(compiler).engine()); @@ -92,9 +94,7 @@ impl WasmerInstance { // Create an empty import object. trace!("Generating imports ..."); - let vm_hooks_wrapper = VMHooksWrapper { - vm_hooks: executor_data.borrow().get_vm_hooks(), - }; + let vm_hooks_wrapper = VMHooksWrapper { vm_hooks }; let import_object = generate_import_object(&store, &vm_hooks_wrapper); trace!("Instantiating WasmerInstance ..."); @@ -113,10 +113,10 @@ impl WasmerInstance { trace!("WasmerMemory size: {:#?}", memory.size()); let memory_name = memories[0].0.clone(); - Ok(Box::new(WasmerInstance { + Ok(WasmerInstance { wasmer_instance, memory_name, - })) + }) } fn get_memory_ref(&self) -> Result<&wasmer::Memory, String> { @@ -173,7 +173,7 @@ fn validate_memory(memory: &wasmer::Memory) -> Result<(), ExecutorError> { fn push_middlewares( compiler: &mut Singlepass, compilation_options: &CompilationOptions, - executor_data: Rc>, + opcode_cost: Arc>, ) { // Create breakpoints middleware let breakpoints_middleware = Arc::new(Breakpoints::new()); @@ -190,7 +190,7 @@ fn push_middlewares( let metering_middleware = Arc::new(Metering::new( compilation_options.gas_limit, compilation_options.unmetered_locals, - executor_data.borrow().get_opcode_cost(), + opcode_cost, breakpoints_middleware.clone(), )); @@ -217,7 +217,7 @@ fn push_middlewares( } } -impl Instance for WasmerInstance { +impl InstanceLegacy for WasmerInstance { fn call(&self, func_name: &str) -> Result<(), String> { trace!("Rust instance call: {func_name}"); @@ -303,7 +303,9 @@ impl Instance for WasmerInstance { match result { Ok(memory) => unsafe { let mem_data = memory.data_unchecked(); - Ok(&mem_data[mem_ptr as usize..=(mem_ptr + mem_length) as usize]) + let start = mem_ptr as usize; + let end = (mem_ptr + mem_length) as usize; + Ok(&mem_data[start..end]) }, Err(err) => Err(err.into()), } diff --git a/vm-executor-wasmer/src/wasmer_metering.rs b/vm-executor-wasmer/src/wasmer_metering.rs index 7d0f848..260bd73 100644 --- a/vm-executor-wasmer/src/wasmer_metering.rs +++ b/vm-executor-wasmer/src/wasmer_metering.rs @@ -1,6 +1,7 @@ use crate::wasmer_breakpoints::{Breakpoints, BREAKPOINT_VALUE_OUT_OF_GAS}; use crate::wasmer_helpers::{ - create_global_index, is_control_flow_operator, MiddlewareWithProtectedGlobals, + create_global_index, get_global_value_u64, is_control_flow_operator, set_global_value_u64, + MiddlewareWithProtectedGlobals, }; use crate::{get_local_cost, get_opcode_cost}; use loupe::{MemoryUsage, MemoryUsageTracker}; @@ -205,45 +206,15 @@ impl FunctionMiddleware for FunctionMetering { } pub(crate) fn set_points_limit(instance: &Instance, limit: u64) -> Result<(), String> { - let result = instance.exports.get_global(METERING_POINTS_LIMIT); - match result { - Ok(global) => { - let result = global.set(limit.into()); - match result { - Ok(_) => Ok(()), - Err(err) => Err(err.message()), - } - } - Err(err) => Err(err.to_string()), - } + set_global_value_u64(instance, METERING_POINTS_LIMIT, limit) } pub(crate) fn set_points_used(instance: &Instance, points: u64) -> Result<(), String> { - let result = instance.exports.get_global(METERING_POINTS_USED); - match result { - Ok(global) => { - let result = global.set(points.into()); - match result { - Ok(_) => Ok(()), - Err(err) => Err(err.message()), - } - } - Err(err) => Err(err.to_string()), - } + set_global_value_u64(instance, METERING_POINTS_USED, points) } pub(crate) fn get_points_used(instance: &Instance) -> Result { - let result = instance.exports.get_global(METERING_POINTS_USED); - match result { - Ok(global) => { - let result = global.get().try_into(); - match result { - Ok(points) => Ok(points), - Err(err) => Err(err.to_string()), - } - } - Err(err) => Err(err.to_string()), - } + get_global_value_u64(instance, METERING_POINTS_USED) } fn check_local_count_exceeded(count: u32) -> Result<(), MiddlewareError> { diff --git a/vm-executor-wasmer/src/wasmer_opcode_control.rs b/vm-executor-wasmer/src/wasmer_opcode_control.rs index 7c1cbe8..631e163 100644 --- a/vm-executor-wasmer/src/wasmer_opcode_control.rs +++ b/vm-executor-wasmer/src/wasmer_opcode_control.rs @@ -202,10 +202,16 @@ impl FunctionMiddleware for FunctionOpcodeControl { state: &mut MiddlewareReaderState<'b>, ) -> Result<(), MiddlewareError> { if matches!(operator, Operator::MemoryGrow { .. }) { - let mut grow_count = self.total_memory_grow_count.lock().map_err(|_| MiddlewareError::new("MemoryGrowLimit", "failed to lock counter"))?; + let mut grow_count = self + .total_memory_grow_count + .lock() + .map_err(|_| MiddlewareError::new("MemoryGrowLimit", "failed to lock counter"))?; *grow_count += 1; if *grow_count > self.max_memory_grow_count { - return Err(MiddlewareError::new("MemoryGrowLimit", "memory.grow limit exceeded")); + return Err(MiddlewareError::new( + "MemoryGrowLimit", + "memory.grow limit exceeded", + )); } self.inject_memory_grow_check(state); diff --git a/vm-executor-wasmer/src/wasmer_service.rs b/vm-executor-wasmer/src/wasmer_service.rs index 30cd25f..3c4e995 100644 --- a/vm-executor-wasmer/src/wasmer_service.rs +++ b/vm-executor-wasmer/src/wasmer_service.rs @@ -1,6 +1,6 @@ use log::trace; use multiversx_chain_vm_executor::{ - Executor, ExecutorError, ExecutorLastError, ExecutorService, VMHooks, + ExecutorError, ExecutorLastError, ExecutorLegacy, ExecutorService, VMHooksLegacy, }; use crate::wasmer_logger as WasmerLogger; @@ -39,8 +39,8 @@ impl ExecutorLastError for BasicExecutorService { impl ExecutorService for BasicExecutorService { fn new_executor( &self, - vm_hooks_builder: Box, - ) -> Result, ExecutorError> { + vm_hooks_builder: Box, + ) -> Result, ExecutorError> { trace!("Initializing WasmerExecutor ..."); Ok(Box::new(WasmerExecutor::new(vm_hooks_builder))) } diff --git a/vm-executor-wasmer/src/wasmer_vm_hooks.rs b/vm-executor-wasmer/src/wasmer_vm_hooks.rs index a63f30f..75307c3 100644 --- a/vm-executor-wasmer/src/wasmer_vm_hooks.rs +++ b/vm-executor-wasmer/src/wasmer_vm_hooks.rs @@ -1,11 +1,11 @@ -use std::rc::Rc; +use std::{cell::RefCell, rc::Rc}; -use multiversx_chain_vm_executor::{MemLength, MemPtr, VMHooks}; +use multiversx_chain_vm_executor::{MemLength, MemPtr, VMHooksLegacy}; use wasmer::WasmerEnv; #[derive(Clone, Debug)] pub struct VMHooksWrapper { - pub vm_hooks: Rc>, + pub vm_hooks: Rc>>, } unsafe impl Send for VMHooksWrapper {} @@ -21,4 +21,12 @@ impl VMHooksWrapper { pub(crate) fn convert_mem_length(&self, raw: i32) -> MemLength { raw as MemLength } + + pub fn with_vm_hooks(&self, f: F) -> R + where + F: FnOnce(&mut dyn VMHooksLegacy) -> R, + { + let mut vm_hooks = self.vm_hooks.borrow_mut(); + f(&mut **vm_hooks) + } } diff --git a/vm-executor-wasmer/tests/common/test_instance.rs b/vm-executor-wasmer/tests/common/test_instance.rs index 6f69269..e049fca 100644 --- a/vm-executor-wasmer/tests/common/test_instance.rs +++ b/vm-executor-wasmer/tests/common/test_instance.rs @@ -1,4 +1,6 @@ -use multiversx_chain_vm_executor::{CompilationOptions, ExecutorService, Instance, VMHooksDefault}; +use multiversx_chain_vm_executor::{ + CompilationOptions, ExecutorService, InstanceLegacy, VMHooksLegacyDefault, +}; use multiversx_chain_vm_executor_wasmer::BasicExecutorService; use wasmer::wat2wasm; @@ -12,10 +14,12 @@ const DUMMY_COMPILATION_OPTIONS: CompilationOptions = CompilationOptions { runtime_breakpoints: false, }; -pub fn test_instance(wat: &str) -> Box { +pub fn test_instance(wat: &str) -> Box { let wasm_bytes = wat2wasm(wat.as_bytes()).unwrap(); let service = BasicExecutorService::new(); - let executor = service.new_executor(Box::new(VMHooksDefault)).unwrap(); + let executor = service + .new_executor(Box::new(VMHooksLegacyDefault)) + .unwrap(); executor .new_instance(&wasm_bytes, &DUMMY_COMPILATION_OPTIONS) .unwrap() diff --git a/vm-executor/Cargo.toml b/vm-executor/Cargo.toml index 2fec9dc..89a29ea 100644 --- a/vm-executor/Cargo.toml +++ b/vm-executor/Cargo.toml @@ -19,3 +19,6 @@ categories = ["cryptography::cryptocurrencies"] [lib] +[dependencies] +serde = { version = "1.0", features = ["derive"] } +toml = "0.7" diff --git a/vm-executor/schedules/gasScheduleV8.toml b/vm-executor/schedules/gasScheduleV8.toml new file mode 100644 index 0000000..7a0c11d --- /dev/null +++ b/vm-executor/schedules/gasScheduleV8.toml @@ -0,0 +1,837 @@ +[BuiltInCost] + ChangeOwnerAddress = 5000000 + ClaimDeveloperRewards = 5000000 + SaveUserName = 1000000 + SaveKeyValue = 100000 + ESDTTransfer = 200000 + ESDTBurn = 100000 + ESDTLocalMint = 50000 + ESDTLocalBurn = 50000 + ESDTNFTCreate = 150000 + ESDTNFTAddQuantity = 50000 + ESDTNFTBurn = 50000 + ESDTNFTTransfer = 200000 + ESDTNFTChangeCreateOwner = 1000000 + ESDTNFTAddUri = 50000 + ESDTNFTUpdateAttributes = 50000 + ESDTNFTMultiTransfer = 200000 + MultiESDTNFTTransfer = 200000 # should be the same value with the ESDTNFTMultiTransfer + ESDTModifyRoyalties = 500000 + ESDTModifyCreator = 500000 + ESDTNFTRecreate = 1000000 + ESDTNFTUpdate = 1000000 + ESDTNFTSetNewURIs = 500000 + SetGuardian = 250000 + GuardAccount = 250000 + UnGuardAccount = 250000 + TrieLoadPerNode = 100000 + TrieStorePerNode = 50000 + +[MetaChainSystemSCsCost] + Stake = 5000000 + UnStake = 5000000 + UnBond = 5000000 + Claim = 5000000 + Get = 5000000 + ChangeRewardAddress = 5000000 + ChangeValidatorKeys = 5000000 + UnJail = 5000000 + DelegationOps = 1000000 + DelegationMgrOps = 50000000 + ValidatorToDelegation = 500000000 + ESDTIssue = 50000000 + ESDTOperations = 50000000 + Proposal = 50000000 + Vote = 5000000 + DelegateVote = 50000000 + RevokeVote = 50000000 + CloseProposal = 50000000 + GetAllNodeStates = 20000000 + UnstakeTokens = 5000000 + UnbondTokens = 5000000 + GetActiveFund = 50000 + FixWaitingListSize = 500000000 + +[BaseOperationCost] + StorePerByte = 10000 + ReleasePerByte = 1000 + DataCopyPerByte = 50 + PersistPerByte = 1000 + CompilePerByte = 300 + AoTPreparePerByte = 100 + GetCode = 1000000 + +[BaseOpsAPICost] + GetSCAddress = 1000 + GetOwnerAddress = 5000 + IsSmartContract = 5000 + GetShardOfAddress = 5000 + GetExternalBalance = 7000 + GetBlockHash = 10000 + TransferValue = 100000 + GetArgument = 1000 + GetFunction = 1000 + GetNumArguments = 1000 + StorageStore = 75000 + StorageLoad = 50000 + CachedStorageLoad = 1000 + GetCaller = 1000 + GetCallValue = 1000 + Log = 3750 + Finish = 1 + SignalError = 1 + GetBlockTimeStamp = 10000 + GetGasLeft = 1000 + Int64GetArgument = 1000 + Int64StorageStore = 75000 + Int64StorageLoad = 50000 + Int64Finish = 1000 + GetStateRootHash = 10000 + GetBlockNonce = 10000 + GetBlockEpoch = 10000 + GetBlockRound = 10000 + GetBlockRandomSeed = 10000 + ExecuteOnSameContext = 100000 + ExecuteOnDestContext = 100000 + DelegateExecution = 100000 + AsyncCallStep = 100000 + AsyncCallbackGasLock = 4000000 + ExecuteReadOnly = 160000 + CreateContract = 300000 + GetReturnData = 1000 + GetNumReturnData = 1000 + GetReturnDataSize = 1000 + GetOriginalTxHash = 10000 + CleanReturnData = 1000 + DeleteFromReturnData = 1000 + GetPrevTxHash = 10000 + GetCurrentTxHash = 10000 + CreateAsyncCall = 200000 + SetAsyncCallback = 100000 + SetAsyncGroupCallback = 100000 + SetAsyncContextCallback = 100000 + GetCallbackClosure = 10000 + GetCodeMetadata = 10000 + IsBuiltinFunction = 10000 + IsReservedFunctionName = 10000 + +[EthAPICost] + UseGas = 100 + GetAddress = 100000 + GetExternalBalance = 70000 + GetBlockHash = 100000 + Call = 160000 + CallDataCopy = 200 + GetCallDataSize = 100 + CallCode = 160000 + CallDelegate = 160000 + CallStatic = 160000 + StorageStore = 250000 + StorageLoad = 100000 + GetCaller = 100 + GetCallValue = 100 + CodeCopy = 1000 + GetCodeSize = 100 + GetBlockCoinbase = 100 + Create = 320000 + GetBlockDifficulty = 100 + ExternalCodeCopy = 3000 + GetExternalCodeSize = 2500 + GetGasLeft = 100 + GetBlockGasLimit = 100000 + GetTxGasPrice = 1000 + Log = 3750 + GetBlockNumber = 100000 + GetTxOrigin = 100000 + Finish = 1 + Revert = 1 + GetReturnDataSize = 200 + ReturnDataCopy = 500 + SelfDestruct = 5000000 + GetBlockTimeStamp = 100000 + +[BigIntAPICost] + BigIntNew = 2000 + BigIntByteLength = 2000 + BigIntUnsignedByteLength = 2000 + BigIntSignedByteLength = 2000 + BigIntGetBytes = 2000 + BigIntGetUnsignedBytes = 2000 + BigIntGetSignedBytes = 2000 + BigIntSetBytes = 2000 + BigIntSetUnsignedBytes = 2000 + BigIntSetSignedBytes = 2000 + BigIntIsInt64 = 2000 + BigIntGetInt64 = 2000 + BigIntSetInt64 = 2000 + BigIntAdd = 2000 + BigIntSub = 2000 + BigIntMul = 6000 + BigIntSqrt = 6000 + BigIntPow = 6000 + BigIntLog = 6000 + BigIntTDiv = 6000 + BigIntTMod = 6000 + BigIntEDiv = 6000 + BigIntEMod = 6000 + BigIntAbs = 2000 + BigIntNeg = 2000 + BigIntSign = 2000 + BigIntCmp = 2000 + BigIntNot = 2000 + BigIntAnd = 2000 + BigIntOr = 2000 + BigIntXor = 2000 + BigIntShr = 2000 + BigIntShl = 2000 + BigIntFinishUnsigned = 1000 + BigIntFinishSigned = 1000 + BigIntStorageLoadUnsigned = 50000 + BigIntStorageStoreUnsigned = 75000 + BigIntGetArgument = 1000 + BigIntGetUnsignedArgument = 1000 + BigIntGetSignedArgument = 1000 + BigIntGetCallValue = 1000 + BigIntGetExternalBalance = 10000 + CopyPerByteForTooBig = 1000 + +[CryptoAPICost] + SHA256 = 1000000 + Keccak256 = 1000000 + Ripemd160 = 1000000 + VerifyBLS = 5000000 + VerifyEd25519 = 2000000 + VerifySecp256k1 = 2000000 + EllipticCurveNew = 10000 + AddECC = 75000 + DoubleECC = 65000 + IsOnCurveECC = 10000 + ScalarMultECC = 400000 + MarshalECC = 13000 + MarshalCompressedECC = 15000 + UnmarshalECC = 20000 + UnmarshalCompressedECC = 270000 + GenerateKeyECC = 7000000 + EncodeDERSig = 10000000 + VerifySecp256r1 = 2000000 + VerifyBLSSignatureShare = 2000000 + VerifyBLSMultiSig = 2000000 + +[ManagedBufferAPICost] + MBufferNew = 2000 + MBufferNewFromBytes = 2000 + MBufferGetLength = 2000 + MBufferGetBytes = 2000 + MBufferGetByteSlice = 2000 + MBufferCopyByteSlice = 2000 + MBufferSetBytes = 2000 + MBufferAppend = 2000 + MBufferAppendBytes = 2000 + MBufferToBigIntUnsigned = 2000 + MBufferToBigIntSigned = 5000 + MBufferFromBigIntUnsigned = 2000 + MBufferFromBigIntSigned = 5000 + MBufferStorageStore = 75000 + MBufferStorageLoad = 50000 + MBufferGetArgument = 1000 + MBufferFinish = 1000 + MBufferSetRandom = 6000 + MBufferToBigFloat = 2000 + MBufferFromBigFloat = 2000 + +[BigFloatAPICost] + BigFloatNewFromParts = 3000 + BigFloatAdd = 7000 + BigFloatSub = 7000 + BigFloatMul = 7000 + BigFloatDiv = 7000 + BigFloatTruncate = 5000 + BigFloatNeg = 5000 + BigFloatClone = 5000 + BigFloatCmp = 4000 + BigFloatAbs = 5000 + BigFloatSqrt = 7000 + BigFloatPow = 10000 + BigFloatFloor = 5000 + BigFloatCeil = 5000 + BigFloatIsInt = 3000 + BigFloatSetBigInt = 3000 + BigFloatSetInt64 = 1000 + BigFloatGetConst = 1000 + +[WASMOpcodeCost] + Unreachable = 5 + Nop = 5 + Block = 5 + Loop = 5 + If = 5 + Else = 5 + End = 5 + Br = 5 + BrIf = 5 + BrTable = 5 + Return = 5 + Call = 5 + CallIndirect = 5 + Drop = 5 + Select = 5 + TypedSelect = 5 + LocalGet = 5 + LocalSet = 5 + LocalTee = 5 + GlobalGet = 5 + GlobalSet = 5 + I32Load = 5 + I64Load = 5 + F32Load = 6 + F64Load = 6 + I32Load8S = 5 + I32Load8U = 5 + I32Load16S = 5 + I32Load16U = 5 + I64Load8S = 5 + I64Load8U = 5 + I64Load16S = 5 + I64Load16U = 5 + I64Load32S = 5 + I64Load32U = 5 + I32Store = 5 + I64Store = 5 + F32Store = 12 + F64Store = 12 + I32Store8 = 5 + I32Store16 = 5 + I64Store8 = 5 + I64Store16 = 5 + I64Store32 = 5 + MemorySize = 5 + MemoryGrow = 1000000 + I32Const = 5 + I64Const = 5 + F32Const = 5 + F64Const = 5 + RefNull = 5 + RefIsNull = 5 + RefFunc = 5 + I32Eqz = 5 + I32Eq = 5 + I32Ne = 5 + I32LtS = 5 + I32LtU = 5 + I32GtS = 5 + I32GtU = 5 + I32LeS = 5 + I32LeU = 5 + I32GeS = 5 + I32GeU = 5 + I64Eqz = 5 + I64Eq = 5 + I64Ne = 5 + I64LtS = 5 + I64LtU = 5 + I64GtS = 5 + I64GtU = 5 + I64LeS = 5 + I64LeU = 5 + I64GeS = 5 + I64GeU = 5 + F32Eq = 6 + F32Ne = 6 + F32Lt = 6 + F32Gt = 6 + F32Le = 6 + F32Ge = 6 + F64Eq = 6 + F64Ne = 6 + F64Lt = 6 + F64Gt = 6 + F64Le = 6 + F64Ge = 6 + I32Clz = 100 + I32Ctz = 100 + I32Popcnt = 100 + I32Add = 5 + I32Sub = 5 + I32Mul = 5 + I32DivS = 18 + I32DivU = 18 + I32RemS = 18 + I32RemU = 18 + I32And = 5 + I32Or = 5 + I32Xor = 5 + I32Shl = 5 + I32ShrS = 5 + I32ShrU = 5 + I32Rotl = 5 + I32Rotr = 5 + I64Clz = 100 + I64Ctz = 100 + I64Popcnt = 100 + I64Add = 5 + I64Sub = 5 + I64Mul = 5 + I64DivS = 18 + I64DivU = 18 + I64RemS = 18 + I64RemU = 18 + I64And = 5 + I64Or = 5 + I64Xor = 5 + I64Shl = 5 + I64ShrS = 5 + I64ShrU = 5 + I64Rotl = 5 + I64Rotr = 5 + F32Abs = 5 + F32Neg = 5 + F32Ceil = 100 + F32Floor = 100 + F32Trunc = 100 + F32Nearest = 100 + F32Sqrt = 100 + F32Add = 5 + F32Sub = 5 + F32Mul = 15 + F32Div = 100 + F32Min = 15 + F32Max = 15 + F32Copysign = 5 + F64Abs = 5 + F64Neg = 5 + F64Ceil = 100 + F64Floor = 100 + F64Trunc = 100 + F64Nearest = 100 + F64Sqrt = 100 + F64Add = 5 + F64Sub = 5 + F64Mul = 15 + F64Div = 100 + F64Min = 15 + F64Max = 15 + F64Copysign = 5 + I32WrapI64 = 9 + I32TruncF32S = 100 + I32TruncF32U = 100 + I32TruncF64S = 100 + I32TruncF64U = 100 + I64ExtendI32S = 9 + I64ExtendI32U = 9 + I64TruncF32S = 100 + I64TruncF32U = 100 + I64TruncF64S = 100 + I64TruncF64U = 100 + F32ConvertI32S = 100 + F32ConvertI32U = 100 + F32ConvertI64S = 100 + F32ConvertI64U = 100 + F32DemoteF64 = 100 + F64ConvertI32S = 100 + F64ConvertI32U = 100 + F64ConvertI64S = 100 + F64ConvertI64U = 100 + F64PromoteF32 = 100 + I32ReinterpretF32 = 100 + I64ReinterpretF64 = 100 + F32ReinterpretI32 = 100 + F64ReinterpretI64 = 100 + I32Extend8S = 9 + I32Extend16S = 9 + I64Extend8S = 9 + I64Extend16S = 9 + I64Extend32S = 9 + I32TruncSatF32S = 100 + I32TruncSatF32U = 100 + I32TruncSatF64S = 100 + I32TruncSatF64U = 100 + I64TruncSatF32S = 100 + I64TruncSatF32U = 100 + I64TruncSatF64S = 100 + I64TruncSatF64U = 100 + MemoryInit = 5 + DataDrop = 5 + MemoryCopy = 5 + MemoryFill = 5 + TableInit = 10 + ElemDrop = 10 + TableCopy = 10 + TableFill = 10 + TableGet = 10 + TableSet = 10 + TableGrow = 10 + TableSize = 10 + AtomicNotify = 1000000 + I32AtomicWait = 1000000 + I64AtomicWait = 1000000 + AtomicFence = 1000000 + I32AtomicLoad = 1000000 + I64AtomicLoad = 1000000 + I32AtomicLoad8U = 1000000 + I32AtomicLoad16U = 1000000 + I64AtomicLoad8U = 1000000 + I64AtomicLoad16U = 1000000 + I64AtomicLoad32U = 1000000 + I32AtomicStore = 1000000 + I64AtomicStore = 1000000 + I32AtomicStore8 = 1000000 + I32AtomicStore16 = 1000000 + I64AtomicStore8 = 1000000 + I64AtomicStore16 = 1000000 + I64AtomicStore32 = 1000000 + I32AtomicRmwAdd = 1000000 + I64AtomicRmwAdd = 1000000 + I32AtomicRmw8AddU = 1000000 + I32AtomicRmw16AddU = 1000000 + I64AtomicRmw8AddU = 1000000 + I64AtomicRmw16AddU = 1000000 + I64AtomicRmw32AddU = 1000000 + I32AtomicRmwSub = 1000000 + I64AtomicRmwSub = 1000000 + I32AtomicRmw8SubU = 1000000 + I32AtomicRmw16SubU = 1000000 + I64AtomicRmw8SubU = 1000000 + I64AtomicRmw16SubU = 1000000 + I64AtomicRmw32SubU = 1000000 + I32AtomicRmwAnd = 1000000 + I64AtomicRmwAnd = 1000000 + I32AtomicRmw8AndU = 1000000 + I32AtomicRmw16AndU = 1000000 + I64AtomicRmw8AndU = 1000000 + I64AtomicRmw16AndU = 1000000 + I64AtomicRmw32AndU = 1000000 + I32AtomicRmwOr = 1000000 + I64AtomicRmwOr = 1000000 + I32AtomicRmw8OrU = 1000000 + I32AtomicRmw16OrU = 1000000 + I64AtomicRmw8OrU = 1000000 + I64AtomicRmw16OrU = 1000000 + I64AtomicRmw32OrU = 1000000 + I32AtomicRmwXor = 1000000 + I64AtomicRmwXor = 1000000 + I32AtomicRmw8XorU = 1000000 + I32AtomicRmw16XorU = 1000000 + I64AtomicRmw8XorU = 1000000 + I64AtomicRmw16XorU = 1000000 + I64AtomicRmw32XorU = 1000000 + I32AtomicRmwXchg = 1000000 + I64AtomicRmwXchg = 1000000 + I32AtomicRmw8XchgU = 1000000 + I32AtomicRmw16XchgU = 1000000 + I64AtomicRmw8XchgU = 1000000 + I64AtomicRmw16XchgU = 1000000 + I64AtomicRmw32XchgU = 1000000 + I32AtomicRmwCmpxchg = 1000000 + I64AtomicRmwCmpxchg = 1000000 + I32AtomicRmw8CmpxchgU = 1000000 + I32AtomicRmw16CmpxchgU = 1000000 + I64AtomicRmw8CmpxchgU = 1000000 + I64AtomicRmw16CmpxchgU = 1000000 + I64AtomicRmw32CmpxchgU = 1000000 + V128Load = 1000000 + V128Store = 1000000 + V128Const = 1000000 + I8x16Splat = 1000000 + I8x16ExtractLaneS = 1000000 + I8x16ExtractLaneU = 1000000 + I8x16ReplaceLane = 1000000 + I16x8Splat = 1000000 + I16x8ExtractLaneS = 1000000 + I16x8ExtractLaneU = 1000000 + I16x8ReplaceLane = 1000000 + I32x4Splat = 1000000 + I32x4ExtractLane = 1000000 + I32x4ReplaceLane = 1000000 + I64x2Splat = 1000000 + I64x2ExtractLane = 1000000 + I64x2ReplaceLane = 1000000 + F32x4Splat = 1000000 + F32x4ExtractLane = 1000000 + F32x4ReplaceLane = 1000000 + F64x2Splat = 1000000 + F64x2ExtractLane = 1000000 + F64x2ReplaceLane = 1000000 + I8x16Eq = 1000000 + I8x16Ne = 1000000 + I8x16LtS = 1000000 + I8x16LtU = 1000000 + I8x16GtS = 1000000 + I8x16GtU = 1000000 + I8x16LeS = 1000000 + I8x16LeU = 1000000 + I8x16GeS = 1000000 + I8x16GeU = 1000000 + I16x8Eq = 1000000 + I16x8Ne = 1000000 + I16x8LtS = 1000000 + I16x8LtU = 1000000 + I16x8GtS = 1000000 + I16x8GtU = 1000000 + I16x8LeS = 1000000 + I16x8LeU = 1000000 + I16x8GeS = 1000000 + I16x8GeU = 1000000 + I32x4Eq = 1000000 + I32x4Ne = 1000000 + I32x4LtS = 1000000 + I32x4LtU = 1000000 + I32x4GtS = 1000000 + I32x4GtU = 1000000 + I32x4LeS = 1000000 + I32x4LeU = 1000000 + I32x4GeS = 1000000 + I32x4GeU = 1000000 + F32x4Eq = 1000000 + F32x4Ne = 1000000 + F32x4Lt = 1000000 + F32x4Gt = 1000000 + F32x4Le = 1000000 + F32x4Ge = 1000000 + F64x2Eq = 1000000 + F64x2Ne = 1000000 + F64x2Lt = 1000000 + F64x2Gt = 1000000 + F64x2Le = 1000000 + F64x2Ge = 1000000 + V128Not = 1000000 + V128And = 1000000 + V128AndNot = 1000000 + V128Or = 1000000 + V128Xor = 1000000 + V128Bitselect = 1000000 + I8x16Neg = 1000000 + I8x16AnyTrue = 1000000 + I8x16AllTrue = 1000000 + I8x16Shl = 1000000 + I8x16ShrS = 1000000 + I8x16ShrU = 1000000 + I8x16Add = 1000000 + I8x16AddSaturateS = 1000000 + I8x16AddSaturateU = 1000000 + I8x16Sub = 1000000 + I8x16SubSaturateS = 1000000 + I8x16SubSaturateU = 1000000 + I8x16MinS = 1000000 + I8x16MinU = 1000000 + I8x16MaxS = 1000000 + I8x16MaxU = 1000000 + I8x16Mul = 1000000 + I16x8Neg = 1000000 + I16x8AnyTrue = 1000000 + I16x8AllTrue = 1000000 + I16x8Shl = 1000000 + I16x8ShrS = 1000000 + I16x8ShrU = 1000000 + I16x8Add = 1000000 + I16x8AddSaturateS = 1000000 + I16x8AddSaturateU = 1000000 + I16x8Sub = 1000000 + I16x8SubSaturateS = 1000000 + I16x8SubSaturateU = 1000000 + I16x8Mul = 1000000 + I16x8MinS = 1000000 + I16x8MinU = 1000000 + I16x8MaxS = 1000000 + I16x8MaxU = 1000000 + I32x4Neg = 1000000 + I32x4AnyTrue = 1000000 + I32x4AllTrue = 1000000 + I32x4Shl = 1000000 + I32x4ShrS = 1000000 + I32x4ShrU = 1000000 + I32x4Add = 1000000 + I32x4Sub = 1000000 + I32x4Mul = 1000000 + I32x4MinS = 1000000 + I32x4MinU = 1000000 + I32x4MaxS = 1000000 + I32x4MaxU = 1000000 + I64x2Neg = 1000000 + I64x2AnyTrue = 1000000 + I64x2AllTrue = 1000000 + I64x2Shl = 1000000 + I64x2ShrS = 1000000 + I64x2ShrU = 1000000 + I64x2Add = 1000000 + I64x2Sub = 1000000 + I64x2Mul = 1000000 + F32x4Abs = 1000000 + F32x4Neg = 1000000 + F32x4Sqrt = 1000000 + F32x4Add = 1000000 + F32x4Sub = 1000000 + F32x4Mul = 1000000 + F32x4Div = 1000000 + F32x4Min = 1000000 + F32x4Max = 1000000 + F64x2Abs = 1000000 + F64x2Neg = 1000000 + F64x2Sqrt = 1000000 + F64x2Add = 1000000 + F64x2Sub = 1000000 + F64x2Mul = 1000000 + F64x2Div = 1000000 + F64x2Min = 1000000 + F64x2Max = 1000000 + I32x4TruncSatF32x4S = 1000000 + I32x4TruncSatF32x4U = 1000000 + I64x2TruncSatF64x2S = 1000000 + I64x2TruncSatF64x2U = 1000000 + F32x4ConvertI32x4S = 1000000 + F32x4ConvertI32x4U = 1000000 + F64x2ConvertI64x2S = 1000000 + F64x2ConvertI64x2U = 1000000 + V8x16Swizzle = 1000000 + V8x16Shuffle = 1000000 + V8x16LoadSplat = 1000000 + V16x8LoadSplat = 1000000 + V32x4LoadSplat = 1000000 + V64x2LoadSplat = 1000000 + I8x16NarrowI16x8S = 1000000 + I8x16NarrowI16x8U = 1000000 + I16x8NarrowI32x4S = 1000000 + I16x8NarrowI32x4U = 1000000 + I16x8WidenLowI8x16S = 1000000 + I16x8WidenHighI8x16S = 1000000 + I16x8WidenLowI8x16U = 1000000 + I16x8WidenHighI8x16U = 1000000 + I32x4WidenLowI16x8S = 1000000 + I32x4WidenHighI16x8S = 1000000 + I32x4WidenLowI16x8U = 1000000 + I32x4WidenHighI16x8U = 1000000 + I16x8Load8x8S = 1000000 + I16x8Load8x8U = 1000000 + I32x4Load16x4S = 1000000 + I32x4Load16x4U = 1000000 + I64x2Load32x2S = 1000000 + I64x2Load32x2U = 1000000 + I8x16RoundingAverageU = 1000000 + I16x8RoundingAverageU = 1000000 + LocalAllocate = 5 + LocalsUnmetered = 100 + MaxMemoryGrowDelta = 1 + MaxMemoryGrow = 10 + Catch = 10 + CatchAll = 10 + Delegate = 10 + Rethrow = 10 + ReturnCall = 10 + ReturnCallIndirect = 10 + Throw = 10 + Try = 10 + Unwind = 10 + F32x4Ceil = 1000000 + F32x4DemoteF64x2Zero = 1000000 + F32x4Floor = 1000000 + F32x4Nearest = 1000000 + F32x4PMax = 1000000 + F32x4PMin = 1000000 + F32x4Trunc = 1000000 + F64x2Ceil = 1000000 + F64x2ConvertLowI32x4S = 1000000 + F64x2ConvertLowI32x4U = 1000000 + F64x2Floor = 1000000 + F64x2Nearest = 1000000 + F64x2PMax = 1000000 + F64x2PMin = 1000000 + F64x2PromoteLowF32x4 = 1000000 + F64x2Trunc = 1000000 + I16x8Abs = 1000000 + I16x8AddSatS = 1000000 + I16x8AddSatU = 1000000 + I16x8Bitmask = 1000000 + I16x8ExtAddPairwiseI8x16S = 1000000 + I16x8ExtAddPairwiseI8x16U = 1000000 + I16x8ExtMulHighI8x16S = 1000000 + I16x8ExtMulHighI8x16U = 1000000 + I16x8ExtMulLowI8x16S = 1000000 + I16x8ExtMulLowI8x16U = 1000000 + I16x8ExtendHighI8x16S = 1000000 + I16x8ExtendHighI8x16U = 1000000 + I16x8ExtendLowI8x16S = 1000000 + I16x8ExtendLowI8x16U = 1000000 + I16x8Q15MulrSatS = 1000000 + I16x8SubSatS = 1000000 + I16x8SubSatU = 1000000 + I32x4Abs = 1000000 + I32x4Bitmask = 1000000 + I32x4DotI16x8S = 1000000 + I32x4ExtAddPairwiseI16x8S = 1000000 + I32x4ExtAddPairwiseI16x8U = 1000000 + I32x4ExtMulHighI16x8S = 1000000 + I32x4ExtMulHighI16x8U = 1000000 + I32x4ExtMulLowI16x8S = 1000000 + I32x4ExtMulLowI16x8U = 1000000 + I32x4ExtendHighI16x8S = 1000000 + I32x4ExtendHighI16x8U = 1000000 + I32x4ExtendLowI16x8S = 1000000 + I32x4ExtendLowI16x8U = 1000000 + I32x4TruncSatF64x2SZero = 1000000 + I32x4TruncSatF64x2UZero = 1000000 + I64x2Abs = 1000000 + I64x2Bitmask = 1000000 + I64x2Eq = 1000000 + I64x2ExtMulHighI32x4S = 1000000 + I64x2ExtMulHighI32x4U = 1000000 + I64x2ExtMulLowI32x4S = 1000000 + I64x2ExtMulLowI32x4U = 1000000 + I64x2ExtendHighI32x4S = 1000000 + I64x2ExtendHighI32x4U = 1000000 + I64x2ExtendLowI32x4S = 1000000 + I64x2ExtendLowI32x4U = 1000000 + I64x2GeS = 1000000 + I64x2GtS = 1000000 + I64x2LeS = 1000000 + I64x2LtS = 1000000 + I64x2Ne = 1000000 + I8x16Abs = 1000000 + I8x16AddSatS = 1000000 + I8x16AddSatU = 1000000 + I8x16Bitmask = 1000000 + I8x16Popcnt = 1000000 + I8x16Shuffle = 1000000 + I8x16SubSatS = 1000000 + I8x16SubSatU = 1000000 + I8x16Swizzle = 1000000 + MemoryAtomicNotify = 1000000 + MemoryAtomicWait32 = 1000000 + MemoryAtomicWait64 = 1000000 + V128AnyTrue = 1000000 + V128Load16Lane = 1000000 + V128Load16Splat = 1000000 + V128Load16x4S = 1000000 + V128Load16x4U = 1000000 + V128Load32Lane = 1000000 + V128Load32Splat = 1000000 + V128Load32Zero = 1000000 + V128Load32x2S = 1000000 + V128Load32x2U = 1000000 + V128Load64Lane = 1000000 + V128Load64Splat = 1000000 + V128Load64Zero = 1000000 + V128Load8Lane = 1000000 + V128Load8Splat = 1000000 + V128Load8x8S = 1000000 + V128Load8x8U = 1000000 + V128Store16Lane = 1000000 + V128Store32Lane = 1000000 + V128Store64Lane = 1000000 + V128Store8Lane = 1000000 + +[MaxPerTransaction] + MaxBuiltInCallsPerTx = 100 + MaxNumberOfTransfersPerTx = 250 + MaxNumberOfTrieReadsPerTx = 1500 + +# Quadratic, Linear and Constant are the coefficients for a quadratic func. Separate variables are used for the +# sign of each coefficient, 0 meaning positive and 1 meaning negative +# The current values for the coefficients were computed based on benchmarking. +# For the given coefficients, the minimum of the function must not be lower than MinimumGasCost +[DynamicStorageLoad] + QuadraticCoefficient = 688 + SignOfQuadratic = 0 + LinearCoefficient = 31858 + SignOfLinear = 0 + ConstantCoefficient = 15287 + SignOfConstant = 0 + MinimumGasCost = 10000 diff --git a/vm-executor/src/breakpoint_value.rs b/vm-executor/src/breakpoint_value.rs index d5b148f..dc3c2eb 100644 --- a/vm-executor/src/breakpoint_value.rs +++ b/vm-executor/src/breakpoint_value.rs @@ -1,3 +1,5 @@ +use std::fmt; + #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum BreakpointValue { /// Lack of a breakpoint @@ -19,6 +21,21 @@ pub enum BreakpointValue { MemoryLimit = 5, } +impl fmt::Display for BreakpointValue { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + BreakpointValue::None => "BreakpointValue: None".fmt(f), + BreakpointValue::ExecutionFailed => "BreakpointValue: ExecutionFailed".fmt(f), + BreakpointValue::AsyncCall => "BreakpointValue: AsyncCall".fmt(f), + BreakpointValue::SignalError => "BreakpointValue: SignalError".fmt(f), + BreakpointValue::OutOfGas => "BreakpointValue: OutOfGas".fmt(f), + BreakpointValue::MemoryLimit => "BreakpointValue: MemoryLimit".fmt(f), + } + } +} + +impl std::error::Error for BreakpointValue {} + impl BreakpointValue { pub fn as_u64(self) -> u64 { self as u64 diff --git a/vm-executor/src/executor.rs b/vm-executor/src/executor.rs index ba54be1..6885df4 100644 --- a/vm-executor/src/executor.rs +++ b/vm-executor/src/executor.rs @@ -1,8 +1,8 @@ -use crate::{CompilationOptions, ExecutorError, Instance, OpcodeCost}; +use crate::{CompilationOptions, ExecutorError, InstanceLegacy, OpcodeCost}; use std::ffi::c_void; -pub trait Executor { +pub trait ExecutorLegacy { /// Sets the data that can be hold by an instance context. fn set_vm_hooks_ptr(&mut self, vm_hooks_ptr: *mut c_void) -> Result<(), ExecutorError>; @@ -14,12 +14,12 @@ pub trait Executor { &self, wasm_bytes: &[u8], compilation_options: &CompilationOptions, - ) -> Result, ExecutorError>; + ) -> Result, ExecutorError>; /// Creates a new VM executor instance from cache. fn new_instance_from_cache( &self, cache_bytes: &[u8], compilation_options: &CompilationOptions, - ) -> Result, ExecutorError>; + ) -> Result, ExecutorError>; } diff --git a/vm-executor/src/executor_new.rs b/vm-executor/src/executor_new.rs new file mode 100644 index 0000000..f2bd2c3 --- /dev/null +++ b/vm-executor/src/executor_new.rs @@ -0,0 +1,17 @@ +use crate::{CompilationOptions, ExecutorError, Instance}; + +pub trait Executor { + /// Creates a new VM executor instance. + fn new_instance( + &self, + wasm_bytes: &[u8], + compilation_options: &CompilationOptions, + ) -> Result, ExecutorError>; + + /// Creates a new VM executor instance from cache. + fn new_instance_from_cache( + &self, + cache_bytes: &[u8], + compilation_options: &CompilationOptions, + ) -> Result, ExecutorError>; +} diff --git a/vm-executor/src/instance.rs b/vm-executor/src/instance.rs index 7ec9e36..5175a23 100644 --- a/vm-executor/src/instance.rs +++ b/vm-executor/src/instance.rs @@ -16,7 +16,10 @@ pub type MemPtr = isize; /// The argument type for dealing with lengths of slices of the executor memory. pub type MemLength = isize; -pub trait Instance { +/// The old instance trait, used both: +/// - from the "outside": configuring & calling the instance; +/// - from the "inside": by VMHooks, to update progress. +pub trait InstanceLegacy { /// Calls an exported function of a WebAssembly instance by `name`. fn call(&self, func_name: &str) -> Result<(), String>; diff --git a/vm-executor/src/instance_new.rs b/vm-executor/src/instance_new.rs new file mode 100644 index 0000000..7383a6d --- /dev/null +++ b/vm-executor/src/instance_new.rs @@ -0,0 +1,38 @@ +use crate::{BreakpointValue, ExecutorError, VMHooksError}; + +pub enum InstanceCallError { + FunctionNotFound, + RuntimeError(ExecutorError), + VMHooksError(VMHooksError), + Breakpoint(BreakpointValue), +} + +/// The new instance trait, only used for configuring & calling the wasmer instance. +pub trait Instance { + /// Calls an exported function of a WebAssembly instance by `name`. + fn call(&self, func_name: &str) -> Result<(), InstanceCallError>; + + /// Checks that all public module functions (SC endpoints) have no arguments or results. + fn check_signatures(&self) -> bool; + + /// Checks whether SC has an endpoint with given name. + fn has_function(&self, func_name: &str) -> bool; + + /// Required to be able to extract all SC endpoint names. + fn get_exported_function_names(&self) -> Vec; + + /// Sets the number of points(gas) limit for the given instance. + fn set_points_limit(&self, limit: u64) -> Result<(), ExecutorError>; + + /// Returns the number of points(gas) used by the given instance. + fn get_points_used(&self) -> Result; + + /// Returns the runtime breakpoint value from the given instance. + fn get_breakpoint_value(&self) -> Result; + + /// Resets an instance, cleaning memories and globals. + fn reset(&self) -> Result<(), ExecutorError>; + + /// Caches an instance. + fn cache(&self) -> Result, ExecutorError>; +} diff --git a/vm-executor/src/instance_state.rs b/vm-executor/src/instance_state.rs new file mode 100644 index 0000000..df166df --- /dev/null +++ b/vm-executor/src/instance_state.rs @@ -0,0 +1,29 @@ +use crate::{BreakpointValue, ExecutorError, MemLength, MemPtr}; + +/// The interface through which VM hooks update the instance state. +pub trait InstanceState { + /// Gets the number of points(gas) limit for the given instance. + fn get_points_limit(&self) -> Result; + + /// Sets the number of points(gas) for the given instance. + fn set_points_used(&mut self, points: u64) -> Result<(), ExecutorError>; + + /// Returns the number of points(gas) used by the given instance. + fn get_points_used(&self) -> Result; + + /// Copies data to new owned buffer. + fn memory_load_to_slice(&self, mem_ptr: MemPtr, dest: &mut [u8]) -> Result<(), ExecutorError>; + + /// Copies data to new owned buffer. + fn memory_load_owned( + &self, + mem_ptr: MemPtr, + mem_length: MemLength, + ) -> Result, ExecutorError>; + + /// Loads data to given slice. In certain cases + fn memory_store(&self, mem_ptr: MemPtr, data: &[u8]) -> Result<(), ExecutorError>; + + /// Sets the runtime breakpoint value for the given instance. + fn set_breakpoint_value(&mut self, value: BreakpointValue) -> Result<(), ExecutorError>; +} diff --git a/vm-executor/src/lib.rs b/vm-executor/src/lib.rs index cfc722f..5c2fdbe 100644 --- a/vm-executor/src/lib.rs +++ b/vm-executor/src/lib.rs @@ -1,15 +1,23 @@ mod breakpoint_value; mod executor; +mod executor_new; mod instance; +mod instance_new; +mod instance_state; mod opcode_cost; mod service_error; mod service_trait; mod vm_hooks; +mod vm_hooks_new; pub use breakpoint_value::*; -pub use executor::*; +pub use executor::ExecutorLegacy; +pub use executor_new::Executor; pub use instance::*; +pub use instance_new::{Instance, InstanceCallError}; +pub use instance_state::InstanceState; pub use opcode_cost::OpcodeCost; pub use service_error::ServiceError; pub use service_trait::*; -pub use vm_hooks::*; +pub use vm_hooks::{VMHooksLegacy, VMHooksLegacyDefault}; +pub use vm_hooks_new::{VMHooks, VMHooksDefault, VMHooksError}; diff --git a/vm-executor/src/opcode_cost.rs b/vm-executor/src/opcode_cost.rs index 0e89f40..9c299c8 100644 --- a/vm-executor/src/opcode_cost.rs +++ b/vm-executor/src/opcode_cost.rs @@ -4,134 +4,265 @@ // !!!!!!!!!!!!!!!!!!!!!! AUTO-GENERATED FILE !!!!!!!!!!!!!!!!!!!!!! // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! -#[derive(Clone, Debug, Default)] +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Debug, Default, Deserialize, Serialize, PartialEq)] +#[serde(default)] pub struct OpcodeCost { + #[serde(rename = "Block", default)] pub opcode_block: u32, + #[serde(rename = "Br", default)] pub opcode_br: u32, + #[serde(rename = "BrIf", default)] pub opcode_brif: u32, + #[serde(rename = "BrTable", default)] pub opcode_brtable: u32, + #[serde(rename = "Call", default)] pub opcode_call: u32, + #[serde(rename = "CallIndirect", default)] pub opcode_callindirect: u32, + #[serde(rename = "Catch", default)] pub opcode_catch: u32, + #[serde(rename = "CatchAll", default)] pub opcode_catchall: u32, + #[serde(rename = "Delegate", default)] pub opcode_delegate: u32, + #[serde(rename = "Drop", default)] pub opcode_drop: u32, + #[serde(rename = "Else", default)] pub opcode_else: u32, + #[serde(rename = "End", default)] pub opcode_end: u32, + #[serde(rename = "GlobalGet", default)] pub opcode_globalget: u32, + #[serde(rename = "GlobalSet", default)] pub opcode_globalset: u32, + #[serde(rename = "I32Add", default)] pub opcode_i32add: u32, + #[serde(rename = "I32And", default)] pub opcode_i32and: u32, + #[serde(rename = "I32Clz", default)] pub opcode_i32clz: u32, + #[serde(rename = "I32Const", default)] pub opcode_i32const: u32, + #[serde(rename = "I32Ctz", default)] pub opcode_i32ctz: u32, + #[serde(rename = "I32DivS", default)] pub opcode_i32divs: u32, + #[serde(rename = "I32DivU", default)] pub opcode_i32divu: u32, + #[serde(rename = "I32Eq", default)] pub opcode_i32eq: u32, + #[serde(rename = "I32Eqz", default)] pub opcode_i32eqz: u32, + #[serde(rename = "I32Extend16S", default)] pub opcode_i32extend16s: u32, + #[serde(rename = "I32Extend8S", default)] pub opcode_i32extend8s: u32, + #[serde(rename = "I32GeS", default)] pub opcode_i32ges: u32, + #[serde(rename = "I32GeU", default)] pub opcode_i32geu: u32, + #[serde(rename = "I32GtS", default)] pub opcode_i32gts: u32, + #[serde(rename = "I32GtU", default)] pub opcode_i32gtu: u32, + #[serde(rename = "I32LeS", default)] pub opcode_i32les: u32, + #[serde(rename = "I32LeU", default)] pub opcode_i32leu: u32, + #[serde(rename = "I32Load", default)] pub opcode_i32load: u32, + #[serde(rename = "I32Load16S", default)] pub opcode_i32load16s: u32, + #[serde(rename = "I32Load16U", default)] pub opcode_i32load16u: u32, + #[serde(rename = "I32Load8S", default)] pub opcode_i32load8s: u32, + #[serde(rename = "I32Load8U", default)] pub opcode_i32load8u: u32, + #[serde(rename = "I32LtS", default)] pub opcode_i32lts: u32, + #[serde(rename = "I32LtU", default)] pub opcode_i32ltu: u32, + #[serde(rename = "I32Mul", default)] pub opcode_i32mul: u32, + #[serde(rename = "I32Ne", default)] pub opcode_i32ne: u32, + #[serde(rename = "I32Or", default)] pub opcode_i32or: u32, + #[serde(rename = "I32Popcnt", default)] pub opcode_i32popcnt: u32, + #[serde(rename = "I32RemS", default)] pub opcode_i32rems: u32, + #[serde(rename = "I32RemU", default)] pub opcode_i32remu: u32, + #[serde(rename = "I32Rotl", default)] pub opcode_i32rotl: u32, + #[serde(rename = "I32Rotr", default)] pub opcode_i32rotr: u32, + #[serde(rename = "I32Shl", default)] pub opcode_i32shl: u32, + #[serde(rename = "I32ShrS", default)] pub opcode_i32shrs: u32, + #[serde(rename = "I32ShrU", default)] pub opcode_i32shru: u32, + #[serde(rename = "I32Store", default)] pub opcode_i32store: u32, + #[serde(rename = "I32Store16", default)] pub opcode_i32store16: u32, + #[serde(rename = "I32Store8", default)] pub opcode_i32store8: u32, + #[serde(rename = "I32Sub", default)] pub opcode_i32sub: u32, + #[serde(rename = "I32WrapI64", default)] pub opcode_i32wrapi64: u32, + #[serde(rename = "I32Xor", default)] pub opcode_i32xor: u32, + #[serde(rename = "I64Add", default)] pub opcode_i64add: u32, + #[serde(rename = "I64And", default)] pub opcode_i64and: u32, + #[serde(rename = "I64Clz", default)] pub opcode_i64clz: u32, + #[serde(rename = "I64Const", default)] pub opcode_i64const: u32, + #[serde(rename = "I64Ctz", default)] pub opcode_i64ctz: u32, + #[serde(rename = "I64DivS", default)] pub opcode_i64divs: u32, + #[serde(rename = "I64DivU", default)] pub opcode_i64divu: u32, + #[serde(rename = "I64Eq", default)] pub opcode_i64eq: u32, + #[serde(rename = "I64Eqz", default)] pub opcode_i64eqz: u32, + #[serde(rename = "I64Extend16S", default)] pub opcode_i64extend16s: u32, + #[serde(rename = "I64Extend32S", default)] pub opcode_i64extend32s: u32, + #[serde(rename = "I64Extend8S", default)] pub opcode_i64extend8s: u32, + #[serde(rename = "I64ExtendI32S", default)] pub opcode_i64extendi32s: u32, + #[serde(rename = "I64ExtendI32U", default)] pub opcode_i64extendi32u: u32, + #[serde(rename = "I64GeS", default)] pub opcode_i64ges: u32, + #[serde(rename = "I64GeU", default)] pub opcode_i64geu: u32, + #[serde(rename = "I64GtS", default)] pub opcode_i64gts: u32, + #[serde(rename = "I64GtU", default)] pub opcode_i64gtu: u32, + #[serde(rename = "I64LeS", default)] pub opcode_i64les: u32, + #[serde(rename = "I64LeU", default)] pub opcode_i64leu: u32, + #[serde(rename = "I64Load", default)] pub opcode_i64load: u32, + #[serde(rename = "I64Load16S", default)] pub opcode_i64load16s: u32, + #[serde(rename = "I64Load16U", default)] pub opcode_i64load16u: u32, + #[serde(rename = "I64Load32S", default)] pub opcode_i64load32s: u32, + #[serde(rename = "I64Load32U", default)] pub opcode_i64load32u: u32, + #[serde(rename = "I64Load8S", default)] pub opcode_i64load8s: u32, + #[serde(rename = "I64Load8U", default)] pub opcode_i64load8u: u32, + #[serde(rename = "I64LtS", default)] pub opcode_i64lts: u32, + #[serde(rename = "I64LtU", default)] pub opcode_i64ltu: u32, + #[serde(rename = "I64Mul", default)] pub opcode_i64mul: u32, + #[serde(rename = "I64Ne", default)] pub opcode_i64ne: u32, + #[serde(rename = "I64Or", default)] pub opcode_i64or: u32, + #[serde(rename = "I64Popcnt", default)] pub opcode_i64popcnt: u32, + #[serde(rename = "I64RemS", default)] pub opcode_i64rems: u32, + #[serde(rename = "I64RemU", default)] pub opcode_i64remu: u32, + #[serde(rename = "I64Rotl", default)] pub opcode_i64rotl: u32, + #[serde(rename = "I64Rotr", default)] pub opcode_i64rotr: u32, + #[serde(rename = "I64Shl", default)] pub opcode_i64shl: u32, + #[serde(rename = "I64ShrS", default)] pub opcode_i64shrs: u32, + #[serde(rename = "I64ShrU", default)] pub opcode_i64shru: u32, + #[serde(rename = "I64Store", default)] pub opcode_i64store: u32, + #[serde(rename = "I64Store16", default)] pub opcode_i64store16: u32, + #[serde(rename = "I64Store32", default)] pub opcode_i64store32: u32, + #[serde(rename = "I64Store8", default)] pub opcode_i64store8: u32, + #[serde(rename = "I64Sub", default)] pub opcode_i64sub: u32, + #[serde(rename = "I64Xor", default)] pub opcode_i64xor: u32, + #[serde(rename = "If", default)] pub opcode_if: u32, + #[serde(rename = "LocalGet", default)] pub opcode_localget: u32, + #[serde(rename = "LocalSet", default)] pub opcode_localset: u32, + #[serde(rename = "LocalTee", default)] pub opcode_localtee: u32, + #[serde(rename = "LocalAllocate", default)] pub opcode_localallocate: u32, + #[serde(rename = "Loop", default)] pub opcode_loop: u32, + #[serde(rename = "MemoryGrow", default)] pub opcode_memorygrow: u32, + #[serde(rename = "MemorySize", default)] pub opcode_memorysize: u32, + #[serde(rename = "Nop", default)] pub opcode_nop: u32, + #[serde(rename = "RefFunc", default)] pub opcode_reffunc: u32, + #[serde(rename = "RefIsNull", default)] pub opcode_refisnull: u32, + #[serde(rename = "RefNull", default)] pub opcode_refnull: u32, + #[serde(rename = "Rethrow", default)] pub opcode_rethrow: u32, + #[serde(rename = "Return", default)] pub opcode_return: u32, + #[serde(rename = "ReturnCall", default)] pub opcode_returncall: u32, + #[serde(rename = "ReturnCallIndirect", default)] pub opcode_returncallindirect: u32, + #[serde(rename = "Select", default)] pub opcode_select: u32, + #[serde(rename = "TableGet", default)] pub opcode_tableget: u32, + #[serde(rename = "TableGrow", default)] pub opcode_tablegrow: u32, + #[serde(rename = "TableInit", default)] pub opcode_tableinit: u32, + #[serde(rename = "TableSet", default)] pub opcode_tableset: u32, + #[serde(rename = "TableSize", default)] pub opcode_tablesize: u32, + #[serde(rename = "Throw", default)] pub opcode_throw: u32, + #[serde(rename = "Try", default)] pub opcode_try: u32, + #[serde(rename = "TypedSelect", default)] pub opcode_typedselect: u32, + #[serde(rename = "Unreachable", default)] pub opcode_unreachable: u32, + #[serde(rename = "Unwind", default)] pub opcode_unwind: u32, } diff --git a/vm-executor/src/service_trait.rs b/vm-executor/src/service_trait.rs index 0c1698a..86ab332 100644 --- a/vm-executor/src/service_trait.rs +++ b/vm-executor/src/service_trait.rs @@ -1,4 +1,4 @@ -use crate::{Executor, VMHooks}; +use crate::{ExecutorLegacy, VMHooksLegacy}; pub type ExecutorError = Box; @@ -14,6 +14,6 @@ pub trait ExecutorService: ExecutorLastError { /// Creates a new VM executor. fn new_executor( &self, - vm_hooks_builder: Box, - ) -> Result, ExecutorError>; + vm_hooks_builder: Box, + ) -> Result, ExecutorError>; } diff --git a/vm-executor/src/vm_hooks.rs b/vm-executor/src/vm_hooks.rs index 88a14eb..ce50cd6 100644 --- a/vm-executor/src/vm_hooks.rs +++ b/vm-executor/src/vm_hooks.rs @@ -10,1493 +10,1493 @@ use crate::{MemLength, MemPtr}; #[rustfmt::skip] #[allow(clippy::too_many_arguments)] -pub trait VMHooks: core::fmt::Debug + 'static { +pub trait VMHooksLegacy: core::fmt::Debug { fn set_vm_hooks_ptr(&mut self, vm_hooks_ptr: *mut c_void); - fn get_gas_left(&self) -> i64; - fn get_sc_address(&self, result_offset: MemPtr); - fn get_owner_address(&self, result_offset: MemPtr); - fn get_shard_of_address(&self, address_offset: MemPtr) -> i32; - fn is_smart_contract(&self, address_offset: MemPtr) -> i32; - fn signal_error(&self, message_offset: MemPtr, message_length: MemLength); - fn get_external_balance(&self, address_offset: MemPtr, result_offset: MemPtr); - fn get_block_hash(&self, nonce: i64, result_offset: MemPtr) -> i32; - fn get_esdt_balance(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, result_offset: MemPtr) -> i32; - fn get_esdt_nft_name_length(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32; - fn get_esdt_nft_attribute_length(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32; - fn get_esdt_nft_uri_length(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32; - fn get_esdt_token_data(&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) -> i32; - fn get_esdt_local_roles(&self, token_id_handle: i32) -> i64; - fn validate_token_identifier(&self, token_id_handle: i32) -> i32; - fn transfer_value(&self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength) -> i32; - fn transfer_value_execute(&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) -> i32; - fn transfer_esdt_execute(&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) -> i32; - fn transfer_esdt_nft_execute(&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) -> i32; - fn multi_transfer_esdt_nft_execute(&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) -> i32; - fn create_async_call(&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) -> i32; - fn set_async_context_callback(&self, callback: MemPtr, callback_length: MemLength, data: MemPtr, data_length: MemLength, gas: i64) -> i32; - fn upgrade_contract(&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); - fn upgrade_from_source_contract(&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); - fn delete_contract(&self, dest_offset: MemPtr, gas_limit: i64, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr); - fn async_call(&self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength); - fn get_argument_length(&self, id: i32) -> i32; - fn get_argument(&self, id: i32, arg_offset: MemPtr) -> i32; - fn get_function(&self, function_offset: MemPtr) -> i32; - fn get_num_arguments(&self) -> i32; - fn storage_store(&self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr, data_length: MemLength) -> i32; - fn storage_load_length(&self, key_offset: MemPtr, key_length: MemLength) -> i32; - fn storage_load_from_address(&self, address_offset: MemPtr, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> i32; - fn storage_load(&self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> i32; - fn set_storage_lock(&self, key_offset: MemPtr, key_length: MemLength, lock_timestamp: i64) -> i32; - fn get_storage_lock(&self, key_offset: MemPtr, key_length: MemLength) -> i64; - fn is_storage_locked(&self, key_offset: MemPtr, key_length: MemLength) -> i32; - fn clear_storage_lock(&self, key_offset: MemPtr, key_length: MemLength) -> i32; - fn get_caller(&self, result_offset: MemPtr); - fn check_no_payment(&self); - fn get_call_value(&self, result_offset: MemPtr) -> i32; - fn get_esdt_value(&self, result_offset: MemPtr) -> i32; - fn get_esdt_value_by_index(&self, result_offset: MemPtr, index: i32) -> i32; - fn get_esdt_token_name(&self, result_offset: MemPtr) -> i32; - fn get_esdt_token_name_by_index(&self, result_offset: MemPtr, index: i32) -> i32; - fn get_esdt_token_nonce(&self) -> i64; - fn get_esdt_token_nonce_by_index(&self, index: i32) -> i64; - fn get_current_esdt_nft_nonce(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength) -> i64; - fn get_esdt_token_type(&self) -> i32; - fn get_esdt_token_type_by_index(&self, index: i32) -> i32; - fn get_num_esdt_transfers(&self) -> i32; - fn get_call_value_token_name(&self, call_value_offset: MemPtr, token_name_offset: MemPtr) -> i32; - fn get_call_value_token_name_by_index(&self, call_value_offset: MemPtr, token_name_offset: MemPtr, index: i32) -> i32; - fn is_reserved_function_name(&self, name_handle: i32) -> i32; - fn write_log(&self, data_pointer: MemPtr, data_length: MemLength, topic_ptr: MemPtr, num_topics: i32); - fn write_event_log(&self, num_topics: i32, topic_lengths_offset: MemPtr, topic_offset: MemPtr, data_offset: MemPtr, data_length: MemLength); - fn get_block_timestamp(&self) -> i64; - fn get_block_nonce(&self) -> i64; - fn get_block_round(&self) -> i64; - fn get_block_epoch(&self) -> i64; - fn get_block_random_seed(&self, pointer: MemPtr); - fn get_state_root_hash(&self, pointer: MemPtr); - fn get_prev_block_timestamp(&self) -> i64; - fn get_prev_block_nonce(&self) -> i64; - fn get_prev_block_round(&self) -> i64; - fn get_prev_block_epoch(&self) -> i64; - fn get_prev_block_random_seed(&self, pointer: MemPtr); - fn finish(&self, pointer: MemPtr, length: MemLength); - fn execute_on_same_context(&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) -> i32; - fn execute_on_dest_context(&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) -> i32; - fn execute_read_only(&self, gas_limit: i64, address_offset: MemPtr, function_offset: MemPtr, function_length: MemLength, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr) -> i32; - fn create_contract(&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) -> i32; - fn deploy_from_source_contract(&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) -> i32; - fn get_num_return_data(&self) -> i32; - fn get_return_data_size(&self, result_id: i32) -> i32; - fn get_return_data(&self, result_id: i32, data_offset: MemPtr) -> i32; - fn clean_return_data(&self); - fn delete_from_return_data(&self, result_id: i32); - fn get_original_tx_hash(&self, data_offset: MemPtr); - fn get_current_tx_hash(&self, data_offset: MemPtr); - fn get_prev_tx_hash(&self, data_offset: MemPtr); - fn managed_sc_address(&self, destination_handle: i32); - fn managed_owner_address(&self, destination_handle: i32); - fn managed_caller(&self, destination_handle: i32); - fn managed_get_original_caller_addr(&self, destination_handle: i32); - fn managed_get_relayer_addr(&self, destination_handle: i32); - fn managed_signal_error(&self, err_handle: i32); - fn managed_write_log(&self, topics_handle: i32, data_handle: i32); - fn managed_get_original_tx_hash(&self, result_handle: i32); - fn managed_get_state_root_hash(&self, result_handle: i32); - fn managed_get_block_random_seed(&self, result_handle: i32); - fn managed_get_prev_block_random_seed(&self, result_handle: i32); - fn managed_get_return_data(&self, result_id: i32, result_handle: i32); - fn managed_get_multi_esdt_call_value(&self, multi_call_value_handle: i32); - fn managed_get_back_transfers(&self, esdt_transfers_value_handle: i32, egld_value_handle: i32); - fn managed_get_esdt_balance(&self, address_handle: i32, token_id_handle: i32, nonce: i64, value_handle: i32); - fn managed_get_esdt_token_data(&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); - fn managed_async_call(&self, dest_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32); - fn managed_create_async_call(&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) -> i32; - fn managed_get_callback_closure(&self, callback_closure_handle: i32); - fn managed_upgrade_from_source_contract(&self, dest_handle: i32, gas: i64, value_handle: i32, address_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_handle: i32); - fn managed_upgrade_contract(&self, dest_handle: i32, gas: i64, value_handle: i32, code_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_handle: i32); - fn managed_delete_contract(&self, dest_handle: i32, gas_limit: i64, arguments_handle: i32); - fn managed_deploy_from_source_contract(&self, gas: i64, value_handle: i32, address_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_address_handle: i32, result_handle: i32) -> i32; - fn managed_create_contract(&self, gas: i64, value_handle: i32, code_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_address_handle: i32, result_handle: i32) -> i32; - fn managed_execute_read_only(&self, gas: i64, address_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32; - fn managed_execute_on_same_context(&self, gas: i64, address_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32; - fn managed_execute_on_dest_context(&self, gas: i64, address_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32; - fn managed_multi_transfer_esdt_nft_execute(&self, dst_handle: i32, token_transfers_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32; - fn managed_multi_transfer_esdt_nft_execute_by_user(&self, user_handle: i32, dst_handle: i32, token_transfers_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32; - fn managed_transfer_value_execute(&self, dst_handle: i32, value_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32; - fn managed_is_esdt_frozen(&self, address_handle: i32, token_id_handle: i32, nonce: i64) -> i32; - fn managed_is_esdt_limited_transfer(&self, token_id_handle: i32) -> i32; - fn managed_is_esdt_paused(&self, token_id_handle: i32) -> i32; - fn managed_buffer_to_hex(&self, source_handle: i32, dest_handle: i32); - fn managed_get_code_metadata(&self, address_handle: i32, response_handle: i32); - fn managed_is_builtin_function(&self, function_name_handle: i32) -> i32; - fn big_float_new_from_parts(&self, integral_part: i32, fractional_part: i32, exponent: i32) -> i32; - fn big_float_new_from_frac(&self, numerator: i64, denominator: i64) -> i32; - fn big_float_new_from_sci(&self, significand: i64, exponent: i64) -> i32; - fn big_float_add(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_float_sub(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_float_mul(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_float_div(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_float_neg(&self, destination_handle: i32, op_handle: i32); - fn big_float_clone(&self, destination_handle: i32, op_handle: i32); - fn big_float_cmp(&self, op1_handle: i32, op2_handle: i32) -> i32; - fn big_float_abs(&self, destination_handle: i32, op_handle: i32); - fn big_float_sign(&self, op_handle: i32) -> i32; - fn big_float_sqrt(&self, destination_handle: i32, op_handle: i32); - fn big_float_pow(&self, destination_handle: i32, op_handle: i32, exponent: i32); - fn big_float_floor(&self, dest_big_int_handle: i32, op_handle: i32); - fn big_float_ceil(&self, dest_big_int_handle: i32, op_handle: i32); - fn big_float_truncate(&self, dest_big_int_handle: i32, op_handle: i32); - fn big_float_set_int64(&self, destination_handle: i32, value: i64); - fn big_float_is_int(&self, op_handle: i32) -> i32; - fn big_float_set_big_int(&self, destination_handle: i32, big_int_handle: i32); - fn big_float_get_const_pi(&self, destination_handle: i32); - fn big_float_get_const_e(&self, destination_handle: i32); - fn big_int_get_unsigned_argument(&self, id: i32, destination_handle: i32); - fn big_int_get_signed_argument(&self, id: i32, destination_handle: i32); - fn big_int_storage_store_unsigned(&self, key_offset: MemPtr, key_length: MemLength, source_handle: i32) -> i32; - fn big_int_storage_load_unsigned(&self, key_offset: MemPtr, key_length: MemLength, destination_handle: i32) -> i32; - fn big_int_get_call_value(&self, destination_handle: i32); - fn big_int_get_esdt_call_value(&self, destination: i32); - fn big_int_get_esdt_call_value_by_index(&self, destination_handle: i32, index: i32); - fn big_int_get_external_balance(&self, address_offset: MemPtr, result: i32); - fn big_int_get_esdt_external_balance(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, result_handle: i32); - fn big_int_new(&self, small_value: i64) -> i32; - fn big_int_unsigned_byte_length(&self, reference_handle: i32) -> i32; - fn big_int_signed_byte_length(&self, reference_handle: i32) -> i32; - fn big_int_get_unsigned_bytes(&self, reference_handle: i32, byte_offset: MemPtr) -> i32; - fn big_int_get_signed_bytes(&self, reference_handle: i32, byte_offset: MemPtr) -> i32; - fn big_int_set_unsigned_bytes(&self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength); - fn big_int_set_signed_bytes(&self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength); - fn big_int_is_int64(&self, destination_handle: i32) -> i32; - fn big_int_get_int64(&self, destination_handle: i32) -> i64; - fn big_int_set_int64(&self, destination_handle: i32, value: i64); - fn big_int_add(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_int_sub(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_int_mul(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_int_tdiv(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_int_tmod(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_int_ediv(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_int_emod(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_int_sqrt(&self, destination_handle: i32, op_handle: i32); - fn big_int_pow(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_int_log2(&self, op1_handle: i32) -> i32; - fn big_int_abs(&self, destination_handle: i32, op_handle: i32); - fn big_int_neg(&self, destination_handle: i32, op_handle: i32); - fn big_int_sign(&self, op_handle: i32) -> i32; - fn big_int_cmp(&self, op1_handle: i32, op2_handle: i32) -> i32; - fn big_int_not(&self, destination_handle: i32, op_handle: i32); - fn big_int_and(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_int_or(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_int_xor(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32); - fn big_int_shr(&self, destination_handle: i32, op_handle: i32, bits: i32); - fn big_int_shl(&self, destination_handle: i32, op_handle: i32, bits: i32); - fn big_int_finish_unsigned(&self, reference_handle: i32); - fn big_int_finish_signed(&self, reference_handle: i32); - fn big_int_to_string(&self, big_int_handle: i32, destination_handle: i32); - fn mbuffer_new(&self) -> i32; - fn mbuffer_new_from_bytes(&self, data_offset: MemPtr, data_length: MemLength) -> i32; - fn mbuffer_get_length(&self, m_buffer_handle: i32) -> i32; - fn mbuffer_get_bytes(&self, m_buffer_handle: i32, result_offset: MemPtr) -> i32; - fn mbuffer_get_byte_slice(&self, source_handle: i32, starting_position: i32, slice_length: i32, result_offset: MemPtr) -> i32; - fn mbuffer_copy_byte_slice(&self, source_handle: i32, starting_position: i32, slice_length: i32, destination_handle: i32) -> i32; - fn mbuffer_eq(&self, m_buffer_handle1: i32, m_buffer_handle2: i32) -> i32; - fn mbuffer_set_bytes(&self, m_buffer_handle: i32, data_offset: MemPtr, data_length: MemLength) -> i32; - fn mbuffer_set_byte_slice(&self, m_buffer_handle: i32, starting_position: i32, data_length: MemLength, data_offset: MemPtr) -> i32; - fn mbuffer_append(&self, accumulator_handle: i32, data_handle: i32) -> i32; - fn mbuffer_append_bytes(&self, accumulator_handle: i32, data_offset: MemPtr, data_length: MemLength) -> i32; - fn mbuffer_to_big_int_unsigned(&self, m_buffer_handle: i32, big_int_handle: i32) -> i32; - fn mbuffer_to_big_int_signed(&self, m_buffer_handle: i32, big_int_handle: i32) -> i32; - fn mbuffer_from_big_int_unsigned(&self, m_buffer_handle: i32, big_int_handle: i32) -> i32; - fn mbuffer_from_big_int_signed(&self, m_buffer_handle: i32, big_int_handle: i32) -> i32; - fn mbuffer_to_big_float(&self, m_buffer_handle: i32, big_float_handle: i32) -> i32; - fn mbuffer_from_big_float(&self, m_buffer_handle: i32, big_float_handle: i32) -> i32; - fn mbuffer_storage_store(&self, key_handle: i32, source_handle: i32) -> i32; - fn mbuffer_storage_load(&self, key_handle: i32, destination_handle: i32) -> i32; - fn mbuffer_storage_load_from_address(&self, address_handle: i32, key_handle: i32, destination_handle: i32); - fn mbuffer_get_argument(&self, id: i32, destination_handle: i32) -> i32; - fn mbuffer_finish(&self, source_handle: i32) -> i32; - fn mbuffer_set_random(&self, destination_handle: i32, length: i32) -> i32; - fn managed_map_new(&self) -> i32; - fn managed_map_put(&self, m_map_handle: i32, key_handle: i32, value_handle: i32) -> i32; - fn managed_map_get(&self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> i32; - fn managed_map_remove(&self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> i32; - fn managed_map_contains(&self, m_map_handle: i32, key_handle: i32) -> i32; - fn small_int_get_unsigned_argument(&self, id: i32) -> i64; - fn small_int_get_signed_argument(&self, id: i32) -> i64; - fn small_int_finish_unsigned(&self, value: i64); - fn small_int_finish_signed(&self, value: i64); - fn small_int_storage_store_unsigned(&self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32; - fn small_int_storage_store_signed(&self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32; - fn small_int_storage_load_unsigned(&self, key_offset: MemPtr, key_length: MemLength) -> i64; - fn small_int_storage_load_signed(&self, key_offset: MemPtr, key_length: MemLength) -> i64; - fn int64get_argument(&self, id: i32) -> i64; - fn int64finish(&self, value: i64); - fn int64storage_store(&self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32; - fn int64storage_load(&self, key_offset: MemPtr, key_length: MemLength) -> i64; - fn sha256(&self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32; - fn managed_sha256(&self, input_handle: i32, output_handle: i32) -> i32; - fn keccak256(&self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32; - fn managed_keccak256(&self, input_handle: i32, output_handle: i32) -> i32; - fn ripemd160(&self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32; - fn managed_ripemd160(&self, input_handle: i32, output_handle: i32) -> i32; - fn verify_bls(&self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32; - fn managed_verify_bls(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32; - fn verify_ed25519(&self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32; - fn managed_verify_ed25519(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32; - fn verify_custom_secp256k1(&self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr, hash_type: i32) -> i32; - fn managed_verify_custom_secp256k1(&self, key_handle: i32, message_handle: i32, sig_handle: i32, hash_type: i32) -> i32; - fn verify_secp256k1(&self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32; - fn managed_verify_secp256k1(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32; - fn encode_secp256k1_der_signature(&self, r_offset: MemPtr, r_length: MemLength, s_offset: MemPtr, s_length: MemLength, sig_offset: MemPtr) -> i32; - fn managed_encode_secp256k1_der_signature(&self, r_handle: i32, s_handle: i32, sig_handle: i32) -> i32; - fn add_ec(&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); - fn double_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32); - fn is_on_curve_ec(&self, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) -> i32; - fn scalar_base_mult_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32; - fn managed_scalar_base_mult_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32; - fn scalar_mult_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32, data_offset: MemPtr, length: MemLength) -> i32; - fn managed_scalar_mult_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32, data_handle: i32) -> i32; - fn marshal_ec(&self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32; - fn managed_marshal_ec(&self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> i32; - fn marshal_compressed_ec(&self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32; - fn managed_marshal_compressed_ec(&self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> i32; - fn unmarshal_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32; - fn managed_unmarshal_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32; - fn unmarshal_compressed_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32; - fn managed_unmarshal_compressed_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32; - fn generate_key_ec(&self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32; - fn managed_generate_key_ec(&self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_handle: i32) -> i32; - fn create_ec(&self, data_offset: MemPtr, data_length: MemLength) -> i32; - fn managed_create_ec(&self, data_handle: i32) -> i32; - fn get_curve_length_ec(&self, ec_handle: i32) -> i32; - fn get_priv_key_byte_length_ec(&self, ec_handle: i32) -> i32; - fn elliptic_curve_get_values(&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) -> i32; - fn managed_verify_secp256r1(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32; - fn managed_verify_blssignature_share(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32; - fn managed_verify_blsaggregated_signature(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32; + fn get_gas_left(&mut self) -> i64; + fn get_sc_address(&mut self, result_offset: MemPtr); + fn get_owner_address(&mut self, result_offset: MemPtr); + fn get_shard_of_address(&mut self, address_offset: MemPtr) -> i32; + fn is_smart_contract(&mut self, address_offset: MemPtr) -> i32; + fn signal_error(&mut self, message_offset: MemPtr, message_length: MemLength); + fn get_external_balance(&mut self, address_offset: MemPtr, result_offset: MemPtr); + fn get_block_hash(&mut self, nonce: i64, result_offset: MemPtr) -> i32; + fn get_esdt_balance(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, result_offset: MemPtr) -> i32; + fn get_esdt_nft_name_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32; + fn get_esdt_nft_attribute_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32; + fn get_esdt_nft_uri_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32; + 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) -> i32; + fn get_esdt_local_roles(&mut self, token_id_handle: i32) -> i64; + fn validate_token_identifier(&mut self, token_id_handle: i32) -> i32; + fn transfer_value(&mut self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength) -> i32; + 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) -> i32; + 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) -> i32; + 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) -> i32; + 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) -> i32; + 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) -> i32; + fn set_async_context_callback(&mut self, callback: MemPtr, callback_length: MemLength, data: MemPtr, data_length: MemLength, gas: i64) -> i32; + 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); + 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); + fn delete_contract(&mut self, dest_offset: MemPtr, gas_limit: i64, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr); + fn async_call(&mut self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength); + fn get_argument_length(&mut self, id: i32) -> i32; + fn get_argument(&mut self, id: i32, arg_offset: MemPtr) -> i32; + fn get_function(&mut self, function_offset: MemPtr) -> i32; + fn get_num_arguments(&mut self) -> i32; + fn storage_store(&mut self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr, data_length: MemLength) -> i32; + fn storage_load_length(&mut self, key_offset: MemPtr, key_length: MemLength) -> i32; + fn storage_load_from_address(&mut self, address_offset: MemPtr, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> i32; + fn storage_load(&mut self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> i32; + fn set_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength, lock_timestamp: i64) -> i32; + fn get_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength) -> i64; + fn is_storage_locked(&mut self, key_offset: MemPtr, key_length: MemLength) -> i32; + fn clear_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength) -> i32; + fn get_caller(&mut self, result_offset: MemPtr); + fn check_no_payment(&mut self); + fn get_call_value(&mut self, result_offset: MemPtr) -> i32; + fn get_esdt_value(&mut self, result_offset: MemPtr) -> i32; + fn get_esdt_value_by_index(&mut self, result_offset: MemPtr, index: i32) -> i32; + fn get_esdt_token_name(&mut self, result_offset: MemPtr) -> i32; + fn get_esdt_token_name_by_index(&mut self, result_offset: MemPtr, index: i32) -> i32; + fn get_esdt_token_nonce(&mut self) -> i64; + fn get_esdt_token_nonce_by_index(&mut self, index: i32) -> i64; + fn get_current_esdt_nft_nonce(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength) -> i64; + fn get_esdt_token_type(&mut self) -> i32; + fn get_esdt_token_type_by_index(&mut self, index: i32) -> i32; + fn get_num_esdt_transfers(&mut self) -> i32; + fn get_call_value_token_name(&mut self, call_value_offset: MemPtr, token_name_offset: MemPtr) -> i32; + fn get_call_value_token_name_by_index(&mut self, call_value_offset: MemPtr, token_name_offset: MemPtr, index: i32) -> i32; + fn is_reserved_function_name(&mut self, name_handle: i32) -> i32; + fn write_log(&mut self, data_pointer: MemPtr, data_length: MemLength, topic_ptr: MemPtr, num_topics: i32); + fn write_event_log(&mut self, num_topics: i32, topic_lengths_offset: MemPtr, topic_offset: MemPtr, data_offset: MemPtr, data_length: MemLength); + fn get_block_timestamp(&mut self) -> i64; + fn get_block_nonce(&mut self) -> i64; + fn get_block_round(&mut self) -> i64; + fn get_block_epoch(&mut self) -> i64; + fn get_block_random_seed(&mut self, pointer: MemPtr); + fn get_state_root_hash(&mut self, pointer: MemPtr); + fn get_prev_block_timestamp(&mut self) -> i64; + fn get_prev_block_nonce(&mut self) -> i64; + fn get_prev_block_round(&mut self) -> i64; + fn get_prev_block_epoch(&mut self) -> i64; + fn get_prev_block_random_seed(&mut self, pointer: MemPtr); + fn finish(&mut self, pointer: MemPtr, length: MemLength); + 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) -> i32; + 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) -> i32; + 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) -> i32; + 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) -> i32; + 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) -> i32; + fn get_num_return_data(&mut self) -> i32; + fn get_return_data_size(&mut self, result_id: i32) -> i32; + fn get_return_data(&mut self, result_id: i32, data_offset: MemPtr) -> i32; + fn clean_return_data(&mut self); + fn delete_from_return_data(&mut self, result_id: i32); + fn get_original_tx_hash(&mut self, data_offset: MemPtr); + fn get_current_tx_hash(&mut self, data_offset: MemPtr); + fn get_prev_tx_hash(&mut self, data_offset: MemPtr); + fn managed_sc_address(&mut self, destination_handle: i32); + fn managed_owner_address(&mut self, destination_handle: i32); + fn managed_caller(&mut self, destination_handle: i32); + fn managed_get_original_caller_addr(&mut self, destination_handle: i32); + fn managed_get_relayer_addr(&mut self, destination_handle: i32); + fn managed_signal_error(&mut self, err_handle: i32); + fn managed_write_log(&mut self, topics_handle: i32, data_handle: i32); + fn managed_get_original_tx_hash(&mut self, result_handle: i32); + fn managed_get_state_root_hash(&mut self, result_handle: i32); + fn managed_get_block_random_seed(&mut self, result_handle: i32); + fn managed_get_prev_block_random_seed(&mut self, result_handle: i32); + fn managed_get_return_data(&mut self, result_id: i32, result_handle: i32); + fn managed_get_multi_esdt_call_value(&mut self, multi_call_value_handle: i32); + fn managed_get_back_transfers(&mut self, esdt_transfers_value_handle: i32, egld_value_handle: i32); + fn managed_get_esdt_balance(&mut self, address_handle: i32, token_id_handle: i32, nonce: i64, value_handle: i32); + 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); + fn managed_async_call(&mut self, dest_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32); + 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) -> i32; + fn managed_get_callback_closure(&mut self, callback_closure_handle: i32); + 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); + 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); + fn managed_delete_contract(&mut self, dest_handle: i32, gas_limit: i64, arguments_handle: i32); + 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) -> i32; + 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) -> i32; + fn managed_execute_read_only(&mut self, gas: i64, address_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32; + 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) -> i32; + 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) -> i32; + 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) -> i32; + 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) -> i32; + fn managed_transfer_value_execute(&mut self, dst_handle: i32, value_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32; + fn managed_is_esdt_frozen(&mut self, address_handle: i32, token_id_handle: i32, nonce: i64) -> i32; + fn managed_is_esdt_limited_transfer(&mut self, token_id_handle: i32) -> i32; + fn managed_is_esdt_paused(&mut self, token_id_handle: i32) -> i32; + fn managed_buffer_to_hex(&mut self, source_handle: i32, dest_handle: i32); + fn managed_get_code_metadata(&mut self, address_handle: i32, response_handle: i32); + fn managed_is_builtin_function(&mut self, function_name_handle: i32) -> i32; + fn big_float_new_from_parts(&mut self, integral_part: i32, fractional_part: i32, exponent: i32) -> i32; + fn big_float_new_from_frac(&mut self, numerator: i64, denominator: i64) -> i32; + fn big_float_new_from_sci(&mut self, significand: i64, exponent: i64) -> i32; + fn big_float_add(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_float_sub(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_float_mul(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_float_div(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_float_neg(&mut self, destination_handle: i32, op_handle: i32); + fn big_float_clone(&mut self, destination_handle: i32, op_handle: i32); + fn big_float_cmp(&mut self, op1_handle: i32, op2_handle: i32) -> i32; + fn big_float_abs(&mut self, destination_handle: i32, op_handle: i32); + fn big_float_sign(&mut self, op_handle: i32) -> i32; + fn big_float_sqrt(&mut self, destination_handle: i32, op_handle: i32); + fn big_float_pow(&mut self, destination_handle: i32, op_handle: i32, exponent: i32); + fn big_float_floor(&mut self, dest_big_int_handle: i32, op_handle: i32); + fn big_float_ceil(&mut self, dest_big_int_handle: i32, op_handle: i32); + fn big_float_truncate(&mut self, dest_big_int_handle: i32, op_handle: i32); + fn big_float_set_int64(&mut self, destination_handle: i32, value: i64); + fn big_float_is_int(&mut self, op_handle: i32) -> i32; + fn big_float_set_big_int(&mut self, destination_handle: i32, big_int_handle: i32); + fn big_float_get_const_pi(&mut self, destination_handle: i32); + fn big_float_get_const_e(&mut self, destination_handle: i32); + fn big_int_get_unsigned_argument(&mut self, id: i32, destination_handle: i32); + fn big_int_get_signed_argument(&mut self, id: i32, destination_handle: i32); + fn big_int_storage_store_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, source_handle: i32) -> i32; + fn big_int_storage_load_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, destination_handle: i32) -> i32; + fn big_int_get_call_value(&mut self, destination_handle: i32); + fn big_int_get_esdt_call_value(&mut self, destination: i32); + fn big_int_get_esdt_call_value_by_index(&mut self, destination_handle: i32, index: i32); + fn big_int_get_external_balance(&mut self, address_offset: MemPtr, result: i32); + 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); + fn big_int_new(&mut self, small_value: i64) -> i32; + fn big_int_unsigned_byte_length(&mut self, reference_handle: i32) -> i32; + fn big_int_signed_byte_length(&mut self, reference_handle: i32) -> i32; + fn big_int_get_unsigned_bytes(&mut self, reference_handle: i32, byte_offset: MemPtr) -> i32; + fn big_int_get_signed_bytes(&mut self, reference_handle: i32, byte_offset: MemPtr) -> i32; + fn big_int_set_unsigned_bytes(&mut self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength); + fn big_int_set_signed_bytes(&mut self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength); + fn big_int_is_int64(&mut self, destination_handle: i32) -> i32; + fn big_int_get_int64(&mut self, destination_handle: i32) -> i64; + fn big_int_set_int64(&mut self, destination_handle: i32, value: i64); + fn big_int_add(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_int_sub(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_int_mul(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_int_tdiv(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_int_tmod(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_int_ediv(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_int_emod(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_int_sqrt(&mut self, destination_handle: i32, op_handle: i32); + fn big_int_pow(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_int_log2(&mut self, op1_handle: i32) -> i32; + fn big_int_abs(&mut self, destination_handle: i32, op_handle: i32); + fn big_int_neg(&mut self, destination_handle: i32, op_handle: i32); + fn big_int_sign(&mut self, op_handle: i32) -> i32; + fn big_int_cmp(&mut self, op1_handle: i32, op2_handle: i32) -> i32; + fn big_int_not(&mut self, destination_handle: i32, op_handle: i32); + fn big_int_and(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_int_or(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_int_xor(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32); + fn big_int_shr(&mut self, destination_handle: i32, op_handle: i32, bits: i32); + fn big_int_shl(&mut self, destination_handle: i32, op_handle: i32, bits: i32); + fn big_int_finish_unsigned(&mut self, reference_handle: i32); + fn big_int_finish_signed(&mut self, reference_handle: i32); + fn big_int_to_string(&mut self, big_int_handle: i32, destination_handle: i32); + fn mbuffer_new(&mut self) -> i32; + fn mbuffer_new_from_bytes(&mut self, data_offset: MemPtr, data_length: MemLength) -> i32; + fn mbuffer_get_length(&mut self, m_buffer_handle: i32) -> i32; + fn mbuffer_get_bytes(&mut self, m_buffer_handle: i32, result_offset: MemPtr) -> i32; + fn mbuffer_get_byte_slice(&mut self, source_handle: i32, starting_position: i32, slice_length: i32, result_offset: MemPtr) -> i32; + fn mbuffer_copy_byte_slice(&mut self, source_handle: i32, starting_position: i32, slice_length: i32, destination_handle: i32) -> i32; + fn mbuffer_eq(&mut self, m_buffer_handle1: i32, m_buffer_handle2: i32) -> i32; + fn mbuffer_set_bytes(&mut self, m_buffer_handle: i32, data_offset: MemPtr, data_length: MemLength) -> i32; + fn mbuffer_set_byte_slice(&mut self, m_buffer_handle: i32, starting_position: i32, data_length: MemLength, data_offset: MemPtr) -> i32; + fn mbuffer_append(&mut self, accumulator_handle: i32, data_handle: i32) -> i32; + fn mbuffer_append_bytes(&mut self, accumulator_handle: i32, data_offset: MemPtr, data_length: MemLength) -> i32; + fn mbuffer_to_big_int_unsigned(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> i32; + fn mbuffer_to_big_int_signed(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> i32; + fn mbuffer_from_big_int_unsigned(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> i32; + fn mbuffer_from_big_int_signed(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> i32; + fn mbuffer_to_big_float(&mut self, m_buffer_handle: i32, big_float_handle: i32) -> i32; + fn mbuffer_from_big_float(&mut self, m_buffer_handle: i32, big_float_handle: i32) -> i32; + fn mbuffer_storage_store(&mut self, key_handle: i32, source_handle: i32) -> i32; + fn mbuffer_storage_load(&mut self, key_handle: i32, destination_handle: i32) -> i32; + fn mbuffer_storage_load_from_address(&mut self, address_handle: i32, key_handle: i32, destination_handle: i32); + fn mbuffer_get_argument(&mut self, id: i32, destination_handle: i32) -> i32; + fn mbuffer_finish(&mut self, source_handle: i32) -> i32; + fn mbuffer_set_random(&mut self, destination_handle: i32, length: i32) -> i32; + fn managed_map_new(&mut self) -> i32; + fn managed_map_put(&mut self, m_map_handle: i32, key_handle: i32, value_handle: i32) -> i32; + fn managed_map_get(&mut self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> i32; + fn managed_map_remove(&mut self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> i32; + fn managed_map_contains(&mut self, m_map_handle: i32, key_handle: i32) -> i32; + fn small_int_get_unsigned_argument(&mut self, id: i32) -> i64; + fn small_int_get_signed_argument(&mut self, id: i32) -> i64; + fn small_int_finish_unsigned(&mut self, value: i64); + fn small_int_finish_signed(&mut self, value: i64); + fn small_int_storage_store_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32; + fn small_int_storage_store_signed(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32; + fn small_int_storage_load_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength) -> i64; + fn small_int_storage_load_signed(&mut self, key_offset: MemPtr, key_length: MemLength) -> i64; + fn int64get_argument(&mut self, id: i32) -> i64; + fn int64finish(&mut self, value: i64); + fn int64storage_store(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32; + fn int64storage_load(&mut self, key_offset: MemPtr, key_length: MemLength) -> i64; + fn sha256(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32; + fn managed_sha256(&mut self, input_handle: i32, output_handle: i32) -> i32; + fn keccak256(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32; + fn managed_keccak256(&mut self, input_handle: i32, output_handle: i32) -> i32; + fn ripemd160(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32; + fn managed_ripemd160(&mut self, input_handle: i32, output_handle: i32) -> i32; + fn verify_bls(&mut self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32; + fn managed_verify_bls(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32; + fn verify_ed25519(&mut self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32; + fn managed_verify_ed25519(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32; + fn verify_custom_secp256k1(&mut self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr, hash_type: i32) -> i32; + fn managed_verify_custom_secp256k1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32, hash_type: i32) -> i32; + fn verify_secp256k1(&mut self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32; + fn managed_verify_secp256k1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32; + fn encode_secp256k1_der_signature(&mut self, r_offset: MemPtr, r_length: MemLength, s_offset: MemPtr, s_length: MemLength, sig_offset: MemPtr) -> i32; + fn managed_encode_secp256k1_der_signature(&mut self, r_handle: i32, s_handle: i32, sig_handle: i32) -> i32; + 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); + fn double_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32); + fn is_on_curve_ec(&mut self, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) -> i32; + fn scalar_base_mult_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32; + fn managed_scalar_base_mult_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32; + 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) -> i32; + 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) -> i32; + fn marshal_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32; + fn managed_marshal_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> i32; + fn marshal_compressed_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32; + fn managed_marshal_compressed_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> i32; + fn unmarshal_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32; + fn managed_unmarshal_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32; + fn unmarshal_compressed_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32; + fn managed_unmarshal_compressed_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32; + fn generate_key_ec(&mut self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32; + fn managed_generate_key_ec(&mut self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_handle: i32) -> i32; + fn create_ec(&mut self, data_offset: MemPtr, data_length: MemLength) -> i32; + fn managed_create_ec(&mut self, data_handle: i32) -> i32; + fn get_curve_length_ec(&mut self, ec_handle: i32) -> i32; + fn get_priv_key_byte_length_ec(&mut self, ec_handle: i32) -> i32; + 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) -> i32; + fn managed_verify_secp256r1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32; + fn managed_verify_blssignature_share(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32; + fn managed_verify_blsaggregated_signature(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32; } /// Dummy implementation for VMHooks. Can be used as placeholder, or in tests. #[derive(Debug)] -pub struct VMHooksDefault; +pub struct VMHooksLegacyDefault; #[allow(unused)] #[rustfmt::skip] -impl VMHooks for VMHooksDefault { +impl VMHooksLegacy for VMHooksLegacyDefault { fn set_vm_hooks_ptr(&mut self, _vm_hooks_ptr: *mut c_void) { } - fn get_gas_left(&self) -> i64 { + fn get_gas_left(&mut self) -> i64 { println!("Called: get_gas_left"); 0 } - fn get_sc_address(&self, result_offset: MemPtr) { + fn get_sc_address(&mut self, result_offset: MemPtr) { println!("Called: get_sc_address"); } - fn get_owner_address(&self, result_offset: MemPtr) { + fn get_owner_address(&mut self, result_offset: MemPtr) { println!("Called: get_owner_address"); } - fn get_shard_of_address(&self, address_offset: MemPtr) -> i32 { + fn get_shard_of_address(&mut self, address_offset: MemPtr) -> i32 { println!("Called: get_shard_of_address"); 0 } - fn is_smart_contract(&self, address_offset: MemPtr) -> i32 { + fn is_smart_contract(&mut self, address_offset: MemPtr) -> i32 { println!("Called: is_smart_contract"); 0 } - fn signal_error(&self, message_offset: MemPtr, message_length: MemLength) { + fn signal_error(&mut self, message_offset: MemPtr, message_length: MemLength) { println!("Called: signal_error"); } - fn get_external_balance(&self, address_offset: MemPtr, result_offset: MemPtr) { + fn get_external_balance(&mut self, address_offset: MemPtr, result_offset: MemPtr) { println!("Called: get_external_balance"); } - fn get_block_hash(&self, nonce: i64, result_offset: MemPtr) -> i32 { + fn get_block_hash(&mut self, nonce: i64, result_offset: MemPtr) -> i32 { println!("Called: get_block_hash"); 0 } - fn get_esdt_balance(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, result_offset: MemPtr) -> i32 { + fn get_esdt_balance(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, result_offset: MemPtr) -> i32 { println!("Called: get_esdt_balance"); 0 } - fn get_esdt_nft_name_length(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32 { + fn get_esdt_nft_name_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32 { println!("Called: get_esdt_nft_name_length"); 0 } - fn get_esdt_nft_attribute_length(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32 { + fn get_esdt_nft_attribute_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32 { println!("Called: get_esdt_nft_attribute_length"); 0 } - fn get_esdt_nft_uri_length(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32 { + fn get_esdt_nft_uri_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> i32 { println!("Called: get_esdt_nft_uri_length"); 0 } - fn get_esdt_token_data(&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) -> i32 { + 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) -> i32 { println!("Called: get_esdt_token_data"); 0 } - fn get_esdt_local_roles(&self, token_id_handle: i32) -> i64 { + fn get_esdt_local_roles(&mut self, token_id_handle: i32) -> i64 { println!("Called: get_esdt_local_roles"); 0 } - fn validate_token_identifier(&self, token_id_handle: i32) -> i32 { + fn validate_token_identifier(&mut self, token_id_handle: i32) -> i32 { println!("Called: validate_token_identifier"); 0 } - fn transfer_value(&self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength) -> i32 { + fn transfer_value(&mut self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength) -> i32 { println!("Called: transfer_value"); 0 } - fn transfer_value_execute(&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) -> i32 { + 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) -> i32 { println!("Called: transfer_value_execute"); 0 } - fn transfer_esdt_execute(&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) -> i32 { + 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) -> i32 { println!("Called: transfer_esdt_execute"); 0 } - fn transfer_esdt_nft_execute(&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) -> i32 { + 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) -> i32 { println!("Called: transfer_esdt_nft_execute"); 0 } - fn multi_transfer_esdt_nft_execute(&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) -> i32 { + 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) -> i32 { println!("Called: multi_transfer_esdt_nft_execute"); 0 } - fn create_async_call(&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) -> i32 { + 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) -> i32 { println!("Called: create_async_call"); 0 } - fn set_async_context_callback(&self, callback: MemPtr, callback_length: MemLength, data: MemPtr, data_length: MemLength, gas: i64) -> i32 { + fn set_async_context_callback(&mut self, callback: MemPtr, callback_length: MemLength, data: MemPtr, data_length: MemLength, gas: i64) -> i32 { println!("Called: set_async_context_callback"); 0 } - fn upgrade_contract(&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) { + 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) { println!("Called: upgrade_contract"); } - fn upgrade_from_source_contract(&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) { + 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) { println!("Called: upgrade_from_source_contract"); } - fn delete_contract(&self, dest_offset: MemPtr, gas_limit: i64, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr) { + fn delete_contract(&mut self, dest_offset: MemPtr, gas_limit: i64, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr) { println!("Called: delete_contract"); } - fn async_call(&self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength) { + fn async_call(&mut self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength) { println!("Called: async_call"); } - fn get_argument_length(&self, id: i32) -> i32 { + fn get_argument_length(&mut self, id: i32) -> i32 { println!("Called: get_argument_length"); 0 } - fn get_argument(&self, id: i32, arg_offset: MemPtr) -> i32 { + fn get_argument(&mut self, id: i32, arg_offset: MemPtr) -> i32 { println!("Called: get_argument"); 0 } - fn get_function(&self, function_offset: MemPtr) -> i32 { + fn get_function(&mut self, function_offset: MemPtr) -> i32 { println!("Called: get_function"); 0 } - fn get_num_arguments(&self) -> i32 { + fn get_num_arguments(&mut self) -> i32 { println!("Called: get_num_arguments"); 0 } - fn storage_store(&self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr, data_length: MemLength) -> i32 { + fn storage_store(&mut self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr, data_length: MemLength) -> i32 { println!("Called: storage_store"); 0 } - fn storage_load_length(&self, key_offset: MemPtr, key_length: MemLength) -> i32 { + fn storage_load_length(&mut self, key_offset: MemPtr, key_length: MemLength) -> i32 { println!("Called: storage_load_length"); 0 } - fn storage_load_from_address(&self, address_offset: MemPtr, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> i32 { + fn storage_load_from_address(&mut self, address_offset: MemPtr, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> i32 { println!("Called: storage_load_from_address"); 0 } - fn storage_load(&self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> i32 { + fn storage_load(&mut self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> i32 { println!("Called: storage_load"); 0 } - fn set_storage_lock(&self, key_offset: MemPtr, key_length: MemLength, lock_timestamp: i64) -> i32 { + fn set_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength, lock_timestamp: i64) -> i32 { println!("Called: set_storage_lock"); 0 } - fn get_storage_lock(&self, key_offset: MemPtr, key_length: MemLength) -> i64 { + fn get_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength) -> i64 { println!("Called: get_storage_lock"); 0 } - fn is_storage_locked(&self, key_offset: MemPtr, key_length: MemLength) -> i32 { + fn is_storage_locked(&mut self, key_offset: MemPtr, key_length: MemLength) -> i32 { println!("Called: is_storage_locked"); 0 } - fn clear_storage_lock(&self, key_offset: MemPtr, key_length: MemLength) -> i32 { + fn clear_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength) -> i32 { println!("Called: clear_storage_lock"); 0 } - fn get_caller(&self, result_offset: MemPtr) { + fn get_caller(&mut self, result_offset: MemPtr) { println!("Called: get_caller"); } - fn check_no_payment(&self) { + fn check_no_payment(&mut self) { println!("Called: check_no_payment"); } - fn get_call_value(&self, result_offset: MemPtr) -> i32 { + fn get_call_value(&mut self, result_offset: MemPtr) -> i32 { println!("Called: get_call_value"); 0 } - fn get_esdt_value(&self, result_offset: MemPtr) -> i32 { + fn get_esdt_value(&mut self, result_offset: MemPtr) -> i32 { println!("Called: get_esdt_value"); 0 } - fn get_esdt_value_by_index(&self, result_offset: MemPtr, index: i32) -> i32 { + fn get_esdt_value_by_index(&mut self, result_offset: MemPtr, index: i32) -> i32 { println!("Called: get_esdt_value_by_index"); 0 } - fn get_esdt_token_name(&self, result_offset: MemPtr) -> i32 { + fn get_esdt_token_name(&mut self, result_offset: MemPtr) -> i32 { println!("Called: get_esdt_token_name"); 0 } - fn get_esdt_token_name_by_index(&self, result_offset: MemPtr, index: i32) -> i32 { + fn get_esdt_token_name_by_index(&mut self, result_offset: MemPtr, index: i32) -> i32 { println!("Called: get_esdt_token_name_by_index"); 0 } - fn get_esdt_token_nonce(&self) -> i64 { + fn get_esdt_token_nonce(&mut self) -> i64 { println!("Called: get_esdt_token_nonce"); 0 } - fn get_esdt_token_nonce_by_index(&self, index: i32) -> i64 { + fn get_esdt_token_nonce_by_index(&mut self, index: i32) -> i64 { println!("Called: get_esdt_token_nonce_by_index"); 0 } - fn get_current_esdt_nft_nonce(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength) -> i64 { + fn get_current_esdt_nft_nonce(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength) -> i64 { println!("Called: get_current_esdt_nft_nonce"); 0 } - fn get_esdt_token_type(&self) -> i32 { + fn get_esdt_token_type(&mut self) -> i32 { println!("Called: get_esdt_token_type"); 0 } - fn get_esdt_token_type_by_index(&self, index: i32) -> i32 { + fn get_esdt_token_type_by_index(&mut self, index: i32) -> i32 { println!("Called: get_esdt_token_type_by_index"); 0 } - fn get_num_esdt_transfers(&self) -> i32 { + fn get_num_esdt_transfers(&mut self) -> i32 { println!("Called: get_num_esdt_transfers"); 0 } - fn get_call_value_token_name(&self, call_value_offset: MemPtr, token_name_offset: MemPtr) -> i32 { + fn get_call_value_token_name(&mut self, call_value_offset: MemPtr, token_name_offset: MemPtr) -> i32 { println!("Called: get_call_value_token_name"); 0 } - fn get_call_value_token_name_by_index(&self, call_value_offset: MemPtr, token_name_offset: MemPtr, index: i32) -> i32 { + fn get_call_value_token_name_by_index(&mut self, call_value_offset: MemPtr, token_name_offset: MemPtr, index: i32) -> i32 { println!("Called: get_call_value_token_name_by_index"); 0 } - fn is_reserved_function_name(&self, name_handle: i32) -> i32 { + fn is_reserved_function_name(&mut self, name_handle: i32) -> i32 { println!("Called: is_reserved_function_name"); 0 } - fn write_log(&self, data_pointer: MemPtr, data_length: MemLength, topic_ptr: MemPtr, num_topics: i32) { + fn write_log(&mut self, data_pointer: MemPtr, data_length: MemLength, topic_ptr: MemPtr, num_topics: i32) { println!("Called: write_log"); } - fn write_event_log(&self, num_topics: i32, topic_lengths_offset: MemPtr, topic_offset: MemPtr, data_offset: MemPtr, data_length: MemLength) { + fn write_event_log(&mut self, num_topics: i32, topic_lengths_offset: MemPtr, topic_offset: MemPtr, data_offset: MemPtr, data_length: MemLength) { println!("Called: write_event_log"); } - fn get_block_timestamp(&self) -> i64 { + fn get_block_timestamp(&mut self) -> i64 { println!("Called: get_block_timestamp"); 0 } - fn get_block_nonce(&self) -> i64 { + fn get_block_nonce(&mut self) -> i64 { println!("Called: get_block_nonce"); 0 } - fn get_block_round(&self) -> i64 { + fn get_block_round(&mut self) -> i64 { println!("Called: get_block_round"); 0 } - fn get_block_epoch(&self) -> i64 { + fn get_block_epoch(&mut self) -> i64 { println!("Called: get_block_epoch"); 0 } - fn get_block_random_seed(&self, pointer: MemPtr) { + fn get_block_random_seed(&mut self, pointer: MemPtr) { println!("Called: get_block_random_seed"); } - fn get_state_root_hash(&self, pointer: MemPtr) { + fn get_state_root_hash(&mut self, pointer: MemPtr) { println!("Called: get_state_root_hash"); } - fn get_prev_block_timestamp(&self) -> i64 { + fn get_prev_block_timestamp(&mut self) -> i64 { println!("Called: get_prev_block_timestamp"); 0 } - fn get_prev_block_nonce(&self) -> i64 { + fn get_prev_block_nonce(&mut self) -> i64 { println!("Called: get_prev_block_nonce"); 0 } - fn get_prev_block_round(&self) -> i64 { + fn get_prev_block_round(&mut self) -> i64 { println!("Called: get_prev_block_round"); 0 } - fn get_prev_block_epoch(&self) -> i64 { + fn get_prev_block_epoch(&mut self) -> i64 { println!("Called: get_prev_block_epoch"); 0 } - fn get_prev_block_random_seed(&self, pointer: MemPtr) { + fn get_prev_block_random_seed(&mut self, pointer: MemPtr) { println!("Called: get_prev_block_random_seed"); } - fn finish(&self, pointer: MemPtr, length: MemLength) { + fn finish(&mut self, pointer: MemPtr, length: MemLength) { println!("Called: finish"); } - fn execute_on_same_context(&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) -> i32 { + 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) -> i32 { println!("Called: execute_on_same_context"); 0 } - fn execute_on_dest_context(&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) -> i32 { + 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) -> i32 { println!("Called: execute_on_dest_context"); 0 } - fn execute_read_only(&self, gas_limit: i64, address_offset: MemPtr, function_offset: MemPtr, function_length: MemLength, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr) -> i32 { + 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) -> i32 { println!("Called: execute_read_only"); 0 } - fn create_contract(&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) -> i32 { + 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) -> i32 { println!("Called: create_contract"); 0 } - fn deploy_from_source_contract(&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) -> i32 { + 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) -> i32 { println!("Called: deploy_from_source_contract"); 0 } - fn get_num_return_data(&self) -> i32 { + fn get_num_return_data(&mut self) -> i32 { println!("Called: get_num_return_data"); 0 } - fn get_return_data_size(&self, result_id: i32) -> i32 { + fn get_return_data_size(&mut self, result_id: i32) -> i32 { println!("Called: get_return_data_size"); 0 } - fn get_return_data(&self, result_id: i32, data_offset: MemPtr) -> i32 { + fn get_return_data(&mut self, result_id: i32, data_offset: MemPtr) -> i32 { println!("Called: get_return_data"); 0 } - fn clean_return_data(&self) { + fn clean_return_data(&mut self) { println!("Called: clean_return_data"); } - fn delete_from_return_data(&self, result_id: i32) { + fn delete_from_return_data(&mut self, result_id: i32) { println!("Called: delete_from_return_data"); } - fn get_original_tx_hash(&self, data_offset: MemPtr) { + fn get_original_tx_hash(&mut self, data_offset: MemPtr) { println!("Called: get_original_tx_hash"); } - fn get_current_tx_hash(&self, data_offset: MemPtr) { + fn get_current_tx_hash(&mut self, data_offset: MemPtr) { println!("Called: get_current_tx_hash"); } - fn get_prev_tx_hash(&self, data_offset: MemPtr) { + fn get_prev_tx_hash(&mut self, data_offset: MemPtr) { println!("Called: get_prev_tx_hash"); } - fn managed_sc_address(&self, destination_handle: i32) { + fn managed_sc_address(&mut self, destination_handle: i32) { println!("Called: managed_sc_address"); } - fn managed_owner_address(&self, destination_handle: i32) { + fn managed_owner_address(&mut self, destination_handle: i32) { println!("Called: managed_owner_address"); } - fn managed_caller(&self, destination_handle: i32) { + fn managed_caller(&mut self, destination_handle: i32) { println!("Called: managed_caller"); } - fn managed_get_original_caller_addr(&self, destination_handle: i32) { + fn managed_get_original_caller_addr(&mut self, destination_handle: i32) { println!("Called: managed_get_original_caller_addr"); } - fn managed_get_relayer_addr(&self, destination_handle: i32) { + fn managed_get_relayer_addr(&mut self, destination_handle: i32) { println!("Called: managed_get_relayer_addr"); } - fn managed_signal_error(&self, err_handle: i32) { + fn managed_signal_error(&mut self, err_handle: i32) { println!("Called: managed_signal_error"); } - fn managed_write_log(&self, topics_handle: i32, data_handle: i32) { + fn managed_write_log(&mut self, topics_handle: i32, data_handle: i32) { println!("Called: managed_write_log"); } - fn managed_get_original_tx_hash(&self, result_handle: i32) { + fn managed_get_original_tx_hash(&mut self, result_handle: i32) { println!("Called: managed_get_original_tx_hash"); } - fn managed_get_state_root_hash(&self, result_handle: i32) { + fn managed_get_state_root_hash(&mut self, result_handle: i32) { println!("Called: managed_get_state_root_hash"); } - fn managed_get_block_random_seed(&self, result_handle: i32) { + fn managed_get_block_random_seed(&mut self, result_handle: i32) { println!("Called: managed_get_block_random_seed"); } - fn managed_get_prev_block_random_seed(&self, result_handle: i32) { + fn managed_get_prev_block_random_seed(&mut self, result_handle: i32) { println!("Called: managed_get_prev_block_random_seed"); } - fn managed_get_return_data(&self, result_id: i32, result_handle: i32) { + fn managed_get_return_data(&mut self, result_id: i32, result_handle: i32) { println!("Called: managed_get_return_data"); } - fn managed_get_multi_esdt_call_value(&self, multi_call_value_handle: i32) { + fn managed_get_multi_esdt_call_value(&mut self, multi_call_value_handle: i32) { println!("Called: managed_get_multi_esdt_call_value"); } - fn managed_get_back_transfers(&self, esdt_transfers_value_handle: i32, egld_value_handle: i32) { + fn managed_get_back_transfers(&mut self, esdt_transfers_value_handle: i32, egld_value_handle: i32) { println!("Called: managed_get_back_transfers"); } - fn managed_get_esdt_balance(&self, address_handle: i32, token_id_handle: i32, nonce: i64, value_handle: i32) { + fn managed_get_esdt_balance(&mut self, address_handle: i32, token_id_handle: i32, nonce: i64, value_handle: i32) { println!("Called: managed_get_esdt_balance"); } - fn managed_get_esdt_token_data(&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) { + 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) { println!("Called: managed_get_esdt_token_data"); } - fn managed_async_call(&self, dest_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32) { + fn managed_async_call(&mut self, dest_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32) { println!("Called: managed_async_call"); } - fn managed_create_async_call(&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) -> i32 { + 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) -> i32 { println!("Called: managed_create_async_call"); 0 } - fn managed_get_callback_closure(&self, callback_closure_handle: i32) { + fn managed_get_callback_closure(&mut self, callback_closure_handle: i32) { println!("Called: managed_get_callback_closure"); } - fn managed_upgrade_from_source_contract(&self, dest_handle: i32, gas: i64, value_handle: i32, address_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_handle: i32) { + 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) { println!("Called: managed_upgrade_from_source_contract"); } - fn managed_upgrade_contract(&self, dest_handle: i32, gas: i64, value_handle: i32, code_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_handle: i32) { + 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) { println!("Called: managed_upgrade_contract"); } - fn managed_delete_contract(&self, dest_handle: i32, gas_limit: i64, arguments_handle: i32) { + fn managed_delete_contract(&mut self, dest_handle: i32, gas_limit: i64, arguments_handle: i32) { println!("Called: managed_delete_contract"); } - fn managed_deploy_from_source_contract(&self, gas: i64, value_handle: i32, address_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_address_handle: i32, result_handle: i32) -> i32 { + 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) -> i32 { println!("Called: managed_deploy_from_source_contract"); 0 } - fn managed_create_contract(&self, gas: i64, value_handle: i32, code_handle: i32, code_metadata_handle: i32, arguments_handle: i32, result_address_handle: i32, result_handle: i32) -> i32 { + 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) -> i32 { println!("Called: managed_create_contract"); 0 } - fn managed_execute_read_only(&self, gas: i64, address_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32 { + fn managed_execute_read_only(&mut self, gas: i64, address_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32 { println!("Called: managed_execute_read_only"); 0 } - fn managed_execute_on_same_context(&self, gas: i64, address_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32 { + 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) -> i32 { println!("Called: managed_execute_on_same_context"); 0 } - fn managed_execute_on_dest_context(&self, gas: i64, address_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> i32 { + 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) -> i32 { println!("Called: managed_execute_on_dest_context"); 0 } - fn managed_multi_transfer_esdt_nft_execute(&self, dst_handle: i32, token_transfers_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32 { + 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) -> i32 { println!("Called: managed_multi_transfer_esdt_nft_execute"); 0 } - fn managed_multi_transfer_esdt_nft_execute_by_user(&self, user_handle: i32, dst_handle: i32, token_transfers_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32 { + 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) -> i32 { println!("Called: managed_multi_transfer_esdt_nft_execute_by_user"); 0 } - fn managed_transfer_value_execute(&self, dst_handle: i32, value_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32 { + fn managed_transfer_value_execute(&mut self, dst_handle: i32, value_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> i32 { println!("Called: managed_transfer_value_execute"); 0 } - fn managed_is_esdt_frozen(&self, address_handle: i32, token_id_handle: i32, nonce: i64) -> i32 { + fn managed_is_esdt_frozen(&mut self, address_handle: i32, token_id_handle: i32, nonce: i64) -> i32 { println!("Called: managed_is_esdt_frozen"); 0 } - fn managed_is_esdt_limited_transfer(&self, token_id_handle: i32) -> i32 { + fn managed_is_esdt_limited_transfer(&mut self, token_id_handle: i32) -> i32 { println!("Called: managed_is_esdt_limited_transfer"); 0 } - fn managed_is_esdt_paused(&self, token_id_handle: i32) -> i32 { + fn managed_is_esdt_paused(&mut self, token_id_handle: i32) -> i32 { println!("Called: managed_is_esdt_paused"); 0 } - fn managed_buffer_to_hex(&self, source_handle: i32, dest_handle: i32) { + fn managed_buffer_to_hex(&mut self, source_handle: i32, dest_handle: i32) { println!("Called: managed_buffer_to_hex"); } - fn managed_get_code_metadata(&self, address_handle: i32, response_handle: i32) { + fn managed_get_code_metadata(&mut self, address_handle: i32, response_handle: i32) { println!("Called: managed_get_code_metadata"); } - fn managed_is_builtin_function(&self, function_name_handle: i32) -> i32 { + fn managed_is_builtin_function(&mut self, function_name_handle: i32) -> i32 { println!("Called: managed_is_builtin_function"); 0 } - fn big_float_new_from_parts(&self, integral_part: i32, fractional_part: i32, exponent: i32) -> i32 { + fn big_float_new_from_parts(&mut self, integral_part: i32, fractional_part: i32, exponent: i32) -> i32 { println!("Called: big_float_new_from_parts"); 0 } - fn big_float_new_from_frac(&self, numerator: i64, denominator: i64) -> i32 { + fn big_float_new_from_frac(&mut self, numerator: i64, denominator: i64) -> i32 { println!("Called: big_float_new_from_frac"); 0 } - fn big_float_new_from_sci(&self, significand: i64, exponent: i64) -> i32 { + fn big_float_new_from_sci(&mut self, significand: i64, exponent: i64) -> i32 { println!("Called: big_float_new_from_sci"); 0 } - fn big_float_add(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_float_add(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_float_add"); } - fn big_float_sub(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_float_sub(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_float_sub"); } - fn big_float_mul(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_float_mul(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_float_mul"); } - fn big_float_div(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_float_div(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_float_div"); } - fn big_float_neg(&self, destination_handle: i32, op_handle: i32) { + fn big_float_neg(&mut self, destination_handle: i32, op_handle: i32) { println!("Called: big_float_neg"); } - fn big_float_clone(&self, destination_handle: i32, op_handle: i32) { + fn big_float_clone(&mut self, destination_handle: i32, op_handle: i32) { println!("Called: big_float_clone"); } - fn big_float_cmp(&self, op1_handle: i32, op2_handle: i32) -> i32 { + fn big_float_cmp(&mut self, op1_handle: i32, op2_handle: i32) -> i32 { println!("Called: big_float_cmp"); 0 } - fn big_float_abs(&self, destination_handle: i32, op_handle: i32) { + fn big_float_abs(&mut self, destination_handle: i32, op_handle: i32) { println!("Called: big_float_abs"); } - fn big_float_sign(&self, op_handle: i32) -> i32 { + fn big_float_sign(&mut self, op_handle: i32) -> i32 { println!("Called: big_float_sign"); 0 } - fn big_float_sqrt(&self, destination_handle: i32, op_handle: i32) { + fn big_float_sqrt(&mut self, destination_handle: i32, op_handle: i32) { println!("Called: big_float_sqrt"); } - fn big_float_pow(&self, destination_handle: i32, op_handle: i32, exponent: i32) { + fn big_float_pow(&mut self, destination_handle: i32, op_handle: i32, exponent: i32) { println!("Called: big_float_pow"); } - fn big_float_floor(&self, dest_big_int_handle: i32, op_handle: i32) { + fn big_float_floor(&mut self, dest_big_int_handle: i32, op_handle: i32) { println!("Called: big_float_floor"); } - fn big_float_ceil(&self, dest_big_int_handle: i32, op_handle: i32) { + fn big_float_ceil(&mut self, dest_big_int_handle: i32, op_handle: i32) { println!("Called: big_float_ceil"); } - fn big_float_truncate(&self, dest_big_int_handle: i32, op_handle: i32) { + fn big_float_truncate(&mut self, dest_big_int_handle: i32, op_handle: i32) { println!("Called: big_float_truncate"); } - fn big_float_set_int64(&self, destination_handle: i32, value: i64) { + fn big_float_set_int64(&mut self, destination_handle: i32, value: i64) { println!("Called: big_float_set_int64"); } - fn big_float_is_int(&self, op_handle: i32) -> i32 { + fn big_float_is_int(&mut self, op_handle: i32) -> i32 { println!("Called: big_float_is_int"); 0 } - fn big_float_set_big_int(&self, destination_handle: i32, big_int_handle: i32) { + fn big_float_set_big_int(&mut self, destination_handle: i32, big_int_handle: i32) { println!("Called: big_float_set_big_int"); } - fn big_float_get_const_pi(&self, destination_handle: i32) { + fn big_float_get_const_pi(&mut self, destination_handle: i32) { println!("Called: big_float_get_const_pi"); } - fn big_float_get_const_e(&self, destination_handle: i32) { + fn big_float_get_const_e(&mut self, destination_handle: i32) { println!("Called: big_float_get_const_e"); } - fn big_int_get_unsigned_argument(&self, id: i32, destination_handle: i32) { + fn big_int_get_unsigned_argument(&mut self, id: i32, destination_handle: i32) { println!("Called: big_int_get_unsigned_argument"); } - fn big_int_get_signed_argument(&self, id: i32, destination_handle: i32) { + fn big_int_get_signed_argument(&mut self, id: i32, destination_handle: i32) { println!("Called: big_int_get_signed_argument"); } - fn big_int_storage_store_unsigned(&self, key_offset: MemPtr, key_length: MemLength, source_handle: i32) -> i32 { + fn big_int_storage_store_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, source_handle: i32) -> i32 { println!("Called: big_int_storage_store_unsigned"); 0 } - fn big_int_storage_load_unsigned(&self, key_offset: MemPtr, key_length: MemLength, destination_handle: i32) -> i32 { + fn big_int_storage_load_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, destination_handle: i32) -> i32 { println!("Called: big_int_storage_load_unsigned"); 0 } - fn big_int_get_call_value(&self, destination_handle: i32) { + fn big_int_get_call_value(&mut self, destination_handle: i32) { println!("Called: big_int_get_call_value"); } - fn big_int_get_esdt_call_value(&self, destination: i32) { + fn big_int_get_esdt_call_value(&mut self, destination: i32) { println!("Called: big_int_get_esdt_call_value"); } - fn big_int_get_esdt_call_value_by_index(&self, destination_handle: i32, index: i32) { + fn big_int_get_esdt_call_value_by_index(&mut self, destination_handle: i32, index: i32) { println!("Called: big_int_get_esdt_call_value_by_index"); } - fn big_int_get_external_balance(&self, address_offset: MemPtr, result: i32) { + fn big_int_get_external_balance(&mut self, address_offset: MemPtr, result: i32) { println!("Called: big_int_get_external_balance"); } - fn big_int_get_esdt_external_balance(&self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, result_handle: i32) { + 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) { println!("Called: big_int_get_esdt_external_balance"); } - fn big_int_new(&self, small_value: i64) -> i32 { + fn big_int_new(&mut self, small_value: i64) -> i32 { println!("Called: big_int_new"); 0 } - fn big_int_unsigned_byte_length(&self, reference_handle: i32) -> i32 { + fn big_int_unsigned_byte_length(&mut self, reference_handle: i32) -> i32 { println!("Called: big_int_unsigned_byte_length"); 0 } - fn big_int_signed_byte_length(&self, reference_handle: i32) -> i32 { + fn big_int_signed_byte_length(&mut self, reference_handle: i32) -> i32 { println!("Called: big_int_signed_byte_length"); 0 } - fn big_int_get_unsigned_bytes(&self, reference_handle: i32, byte_offset: MemPtr) -> i32 { + fn big_int_get_unsigned_bytes(&mut self, reference_handle: i32, byte_offset: MemPtr) -> i32 { println!("Called: big_int_get_unsigned_bytes"); 0 } - fn big_int_get_signed_bytes(&self, reference_handle: i32, byte_offset: MemPtr) -> i32 { + fn big_int_get_signed_bytes(&mut self, reference_handle: i32, byte_offset: MemPtr) -> i32 { println!("Called: big_int_get_signed_bytes"); 0 } - fn big_int_set_unsigned_bytes(&self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength) { + fn big_int_set_unsigned_bytes(&mut self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength) { println!("Called: big_int_set_unsigned_bytes"); } - fn big_int_set_signed_bytes(&self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength) { + fn big_int_set_signed_bytes(&mut self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength) { println!("Called: big_int_set_signed_bytes"); } - fn big_int_is_int64(&self, destination_handle: i32) -> i32 { + fn big_int_is_int64(&mut self, destination_handle: i32) -> i32 { println!("Called: big_int_is_int64"); 0 } - fn big_int_get_int64(&self, destination_handle: i32) -> i64 { + fn big_int_get_int64(&mut self, destination_handle: i32) -> i64 { println!("Called: big_int_get_int64"); 0 } - fn big_int_set_int64(&self, destination_handle: i32, value: i64) { + fn big_int_set_int64(&mut self, destination_handle: i32, value: i64) { println!("Called: big_int_set_int64"); } - fn big_int_add(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_add(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_int_add"); } - fn big_int_sub(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_sub(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_int_sub"); } - fn big_int_mul(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_mul(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_int_mul"); } - fn big_int_tdiv(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_tdiv(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_int_tdiv"); } - fn big_int_tmod(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_tmod(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_int_tmod"); } - fn big_int_ediv(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_ediv(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_int_ediv"); } - fn big_int_emod(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_emod(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_int_emod"); } - fn big_int_sqrt(&self, destination_handle: i32, op_handle: i32) { + fn big_int_sqrt(&mut self, destination_handle: i32, op_handle: i32) { println!("Called: big_int_sqrt"); } - fn big_int_pow(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_pow(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_int_pow"); } - fn big_int_log2(&self, op1_handle: i32) -> i32 { + fn big_int_log2(&mut self, op1_handle: i32) -> i32 { println!("Called: big_int_log2"); 0 } - fn big_int_abs(&self, destination_handle: i32, op_handle: i32) { + fn big_int_abs(&mut self, destination_handle: i32, op_handle: i32) { println!("Called: big_int_abs"); } - fn big_int_neg(&self, destination_handle: i32, op_handle: i32) { + fn big_int_neg(&mut self, destination_handle: i32, op_handle: i32) { println!("Called: big_int_neg"); } - fn big_int_sign(&self, op_handle: i32) -> i32 { + fn big_int_sign(&mut self, op_handle: i32) -> i32 { println!("Called: big_int_sign"); 0 } - fn big_int_cmp(&self, op1_handle: i32, op2_handle: i32) -> i32 { + fn big_int_cmp(&mut self, op1_handle: i32, op2_handle: i32) -> i32 { println!("Called: big_int_cmp"); 0 } - fn big_int_not(&self, destination_handle: i32, op_handle: i32) { + fn big_int_not(&mut self, destination_handle: i32, op_handle: i32) { println!("Called: big_int_not"); } - fn big_int_and(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_and(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_int_and"); } - fn big_int_or(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_or(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_int_or"); } - fn big_int_xor(&self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { + fn big_int_xor(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) { println!("Called: big_int_xor"); } - fn big_int_shr(&self, destination_handle: i32, op_handle: i32, bits: i32) { + fn big_int_shr(&mut self, destination_handle: i32, op_handle: i32, bits: i32) { println!("Called: big_int_shr"); } - fn big_int_shl(&self, destination_handle: i32, op_handle: i32, bits: i32) { + fn big_int_shl(&mut self, destination_handle: i32, op_handle: i32, bits: i32) { println!("Called: big_int_shl"); } - fn big_int_finish_unsigned(&self, reference_handle: i32) { + fn big_int_finish_unsigned(&mut self, reference_handle: i32) { println!("Called: big_int_finish_unsigned"); } - fn big_int_finish_signed(&self, reference_handle: i32) { + fn big_int_finish_signed(&mut self, reference_handle: i32) { println!("Called: big_int_finish_signed"); } - fn big_int_to_string(&self, big_int_handle: i32, destination_handle: i32) { + fn big_int_to_string(&mut self, big_int_handle: i32, destination_handle: i32) { println!("Called: big_int_to_string"); } - fn mbuffer_new(&self) -> i32 { + fn mbuffer_new(&mut self) -> i32 { println!("Called: mbuffer_new"); 0 } - fn mbuffer_new_from_bytes(&self, data_offset: MemPtr, data_length: MemLength) -> i32 { + fn mbuffer_new_from_bytes(&mut self, data_offset: MemPtr, data_length: MemLength) -> i32 { println!("Called: mbuffer_new_from_bytes"); 0 } - fn mbuffer_get_length(&self, m_buffer_handle: i32) -> i32 { + fn mbuffer_get_length(&mut self, m_buffer_handle: i32) -> i32 { println!("Called: mbuffer_get_length"); 0 } - fn mbuffer_get_bytes(&self, m_buffer_handle: i32, result_offset: MemPtr) -> i32 { + fn mbuffer_get_bytes(&mut self, m_buffer_handle: i32, result_offset: MemPtr) -> i32 { println!("Called: mbuffer_get_bytes"); 0 } - fn mbuffer_get_byte_slice(&self, source_handle: i32, starting_position: i32, slice_length: i32, result_offset: MemPtr) -> i32 { + fn mbuffer_get_byte_slice(&mut self, source_handle: i32, starting_position: i32, slice_length: i32, result_offset: MemPtr) -> i32 { println!("Called: mbuffer_get_byte_slice"); 0 } - fn mbuffer_copy_byte_slice(&self, source_handle: i32, starting_position: i32, slice_length: i32, destination_handle: i32) -> i32 { + fn mbuffer_copy_byte_slice(&mut self, source_handle: i32, starting_position: i32, slice_length: i32, destination_handle: i32) -> i32 { println!("Called: mbuffer_copy_byte_slice"); 0 } - fn mbuffer_eq(&self, m_buffer_handle1: i32, m_buffer_handle2: i32) -> i32 { + fn mbuffer_eq(&mut self, m_buffer_handle1: i32, m_buffer_handle2: i32) -> i32 { println!("Called: mbuffer_eq"); 0 } - fn mbuffer_set_bytes(&self, m_buffer_handle: i32, data_offset: MemPtr, data_length: MemLength) -> i32 { + fn mbuffer_set_bytes(&mut self, m_buffer_handle: i32, data_offset: MemPtr, data_length: MemLength) -> i32 { println!("Called: mbuffer_set_bytes"); 0 } - fn mbuffer_set_byte_slice(&self, m_buffer_handle: i32, starting_position: i32, data_length: MemLength, data_offset: MemPtr) -> i32 { + fn mbuffer_set_byte_slice(&mut self, m_buffer_handle: i32, starting_position: i32, data_length: MemLength, data_offset: MemPtr) -> i32 { println!("Called: mbuffer_set_byte_slice"); 0 } - fn mbuffer_append(&self, accumulator_handle: i32, data_handle: i32) -> i32 { + fn mbuffer_append(&mut self, accumulator_handle: i32, data_handle: i32) -> i32 { println!("Called: mbuffer_append"); 0 } - fn mbuffer_append_bytes(&self, accumulator_handle: i32, data_offset: MemPtr, data_length: MemLength) -> i32 { + fn mbuffer_append_bytes(&mut self, accumulator_handle: i32, data_offset: MemPtr, data_length: MemLength) -> i32 { println!("Called: mbuffer_append_bytes"); 0 } - fn mbuffer_to_big_int_unsigned(&self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { + fn mbuffer_to_big_int_unsigned(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { println!("Called: mbuffer_to_big_int_unsigned"); 0 } - fn mbuffer_to_big_int_signed(&self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { + fn mbuffer_to_big_int_signed(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { println!("Called: mbuffer_to_big_int_signed"); 0 } - fn mbuffer_from_big_int_unsigned(&self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { + fn mbuffer_from_big_int_unsigned(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { println!("Called: mbuffer_from_big_int_unsigned"); 0 } - fn mbuffer_from_big_int_signed(&self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { + fn mbuffer_from_big_int_signed(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> i32 { println!("Called: mbuffer_from_big_int_signed"); 0 } - fn mbuffer_to_big_float(&self, m_buffer_handle: i32, big_float_handle: i32) -> i32 { + fn mbuffer_to_big_float(&mut self, m_buffer_handle: i32, big_float_handle: i32) -> i32 { println!("Called: mbuffer_to_big_float"); 0 } - fn mbuffer_from_big_float(&self, m_buffer_handle: i32, big_float_handle: i32) -> i32 { + fn mbuffer_from_big_float(&mut self, m_buffer_handle: i32, big_float_handle: i32) -> i32 { println!("Called: mbuffer_from_big_float"); 0 } - fn mbuffer_storage_store(&self, key_handle: i32, source_handle: i32) -> i32 { + fn mbuffer_storage_store(&mut self, key_handle: i32, source_handle: i32) -> i32 { println!("Called: mbuffer_storage_store"); 0 } - fn mbuffer_storage_load(&self, key_handle: i32, destination_handle: i32) -> i32 { + fn mbuffer_storage_load(&mut self, key_handle: i32, destination_handle: i32) -> i32 { println!("Called: mbuffer_storage_load"); 0 } - fn mbuffer_storage_load_from_address(&self, address_handle: i32, key_handle: i32, destination_handle: i32) { + fn mbuffer_storage_load_from_address(&mut self, address_handle: i32, key_handle: i32, destination_handle: i32) { println!("Called: mbuffer_storage_load_from_address"); } - fn mbuffer_get_argument(&self, id: i32, destination_handle: i32) -> i32 { + fn mbuffer_get_argument(&mut self, id: i32, destination_handle: i32) -> i32 { println!("Called: mbuffer_get_argument"); 0 } - fn mbuffer_finish(&self, source_handle: i32) -> i32 { + fn mbuffer_finish(&mut self, source_handle: i32) -> i32 { println!("Called: mbuffer_finish"); 0 } - fn mbuffer_set_random(&self, destination_handle: i32, length: i32) -> i32 { + fn mbuffer_set_random(&mut self, destination_handle: i32, length: i32) -> i32 { println!("Called: mbuffer_set_random"); 0 } - fn managed_map_new(&self) -> i32 { + fn managed_map_new(&mut self) -> i32 { println!("Called: managed_map_new"); 0 } - fn managed_map_put(&self, m_map_handle: i32, key_handle: i32, value_handle: i32) -> i32 { + fn managed_map_put(&mut self, m_map_handle: i32, key_handle: i32, value_handle: i32) -> i32 { println!("Called: managed_map_put"); 0 } - fn managed_map_get(&self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> i32 { + fn managed_map_get(&mut self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> i32 { println!("Called: managed_map_get"); 0 } - fn managed_map_remove(&self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> i32 { + fn managed_map_remove(&mut self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> i32 { println!("Called: managed_map_remove"); 0 } - fn managed_map_contains(&self, m_map_handle: i32, key_handle: i32) -> i32 { + fn managed_map_contains(&mut self, m_map_handle: i32, key_handle: i32) -> i32 { println!("Called: managed_map_contains"); 0 } - fn small_int_get_unsigned_argument(&self, id: i32) -> i64 { + fn small_int_get_unsigned_argument(&mut self, id: i32) -> i64 { println!("Called: small_int_get_unsigned_argument"); 0 } - fn small_int_get_signed_argument(&self, id: i32) -> i64 { + fn small_int_get_signed_argument(&mut self, id: i32) -> i64 { println!("Called: small_int_get_signed_argument"); 0 } - fn small_int_finish_unsigned(&self, value: i64) { + fn small_int_finish_unsigned(&mut self, value: i64) { println!("Called: small_int_finish_unsigned"); } - fn small_int_finish_signed(&self, value: i64) { + fn small_int_finish_signed(&mut self, value: i64) { println!("Called: small_int_finish_signed"); } - fn small_int_storage_store_unsigned(&self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32 { + fn small_int_storage_store_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32 { println!("Called: small_int_storage_store_unsigned"); 0 } - fn small_int_storage_store_signed(&self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32 { + fn small_int_storage_store_signed(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32 { println!("Called: small_int_storage_store_signed"); 0 } - fn small_int_storage_load_unsigned(&self, key_offset: MemPtr, key_length: MemLength) -> i64 { + fn small_int_storage_load_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength) -> i64 { println!("Called: small_int_storage_load_unsigned"); 0 } - fn small_int_storage_load_signed(&self, key_offset: MemPtr, key_length: MemLength) -> i64 { + fn small_int_storage_load_signed(&mut self, key_offset: MemPtr, key_length: MemLength) -> i64 { println!("Called: small_int_storage_load_signed"); 0 } - fn int64get_argument(&self, id: i32) -> i64 { + fn int64get_argument(&mut self, id: i32) -> i64 { println!("Called: int64get_argument"); 0 } - fn int64finish(&self, value: i64) { + fn int64finish(&mut self, value: i64) { println!("Called: int64finish"); } - fn int64storage_store(&self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32 { + fn int64storage_store(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> i32 { println!("Called: int64storage_store"); 0 } - fn int64storage_load(&self, key_offset: MemPtr, key_length: MemLength) -> i64 { + fn int64storage_load(&mut self, key_offset: MemPtr, key_length: MemLength) -> i64 { println!("Called: int64storage_load"); 0 } - fn sha256(&self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32 { + fn sha256(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32 { println!("Called: sha256"); 0 } - fn managed_sha256(&self, input_handle: i32, output_handle: i32) -> i32 { + fn managed_sha256(&mut self, input_handle: i32, output_handle: i32) -> i32 { println!("Called: managed_sha256"); 0 } - fn keccak256(&self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32 { + fn keccak256(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32 { println!("Called: keccak256"); 0 } - fn managed_keccak256(&self, input_handle: i32, output_handle: i32) -> i32 { + fn managed_keccak256(&mut self, input_handle: i32, output_handle: i32) -> i32 { println!("Called: managed_keccak256"); 0 } - fn ripemd160(&self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32 { + fn ripemd160(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> i32 { println!("Called: ripemd160"); 0 } - fn managed_ripemd160(&self, input_handle: i32, output_handle: i32) -> i32 { + fn managed_ripemd160(&mut self, input_handle: i32, output_handle: i32) -> i32 { println!("Called: managed_ripemd160"); 0 } - fn verify_bls(&self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32 { + fn verify_bls(&mut self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32 { println!("Called: verify_bls"); 0 } - fn managed_verify_bls(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { + fn managed_verify_bls(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { println!("Called: managed_verify_bls"); 0 } - fn verify_ed25519(&self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32 { + fn verify_ed25519(&mut self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32 { println!("Called: verify_ed25519"); 0 } - fn managed_verify_ed25519(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { + fn managed_verify_ed25519(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { println!("Called: managed_verify_ed25519"); 0 } - fn verify_custom_secp256k1(&self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr, hash_type: i32) -> i32 { + fn verify_custom_secp256k1(&mut self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr, hash_type: i32) -> i32 { println!("Called: verify_custom_secp256k1"); 0 } - fn managed_verify_custom_secp256k1(&self, key_handle: i32, message_handle: i32, sig_handle: i32, hash_type: i32) -> i32 { + fn managed_verify_custom_secp256k1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32, hash_type: i32) -> i32 { println!("Called: managed_verify_custom_secp256k1"); 0 } - fn verify_secp256k1(&self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32 { + fn verify_secp256k1(&mut self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> i32 { println!("Called: verify_secp256k1"); 0 } - fn managed_verify_secp256k1(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { + fn managed_verify_secp256k1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { println!("Called: managed_verify_secp256k1"); 0 } - fn encode_secp256k1_der_signature(&self, r_offset: MemPtr, r_length: MemLength, s_offset: MemPtr, s_length: MemLength, sig_offset: MemPtr) -> i32 { + fn encode_secp256k1_der_signature(&mut self, r_offset: MemPtr, r_length: MemLength, s_offset: MemPtr, s_length: MemLength, sig_offset: MemPtr) -> i32 { println!("Called: encode_secp256k1_der_signature"); 0 } - fn managed_encode_secp256k1_der_signature(&self, r_handle: i32, s_handle: i32, sig_handle: i32) -> i32 { + fn managed_encode_secp256k1_der_signature(&mut self, r_handle: i32, s_handle: i32, sig_handle: i32) -> i32 { println!("Called: managed_encode_secp256k1_der_signature"); 0 } - fn add_ec(&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) { + 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) { println!("Called: add_ec"); } - fn double_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) { + fn double_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) { println!("Called: double_ec"); } - fn is_on_curve_ec(&self, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) -> i32 { + fn is_on_curve_ec(&mut self, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) -> i32 { println!("Called: is_on_curve_ec"); 0 } - fn scalar_base_mult_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32 { + fn scalar_base_mult_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32 { println!("Called: scalar_base_mult_ec"); 0 } - fn managed_scalar_base_mult_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { + fn managed_scalar_base_mult_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { println!("Called: managed_scalar_base_mult_ec"); 0 } - fn scalar_mult_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32, data_offset: MemPtr, length: MemLength) -> i32 { + 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) -> i32 { println!("Called: scalar_mult_ec"); 0 } - fn managed_scalar_mult_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32, data_handle: i32) -> i32 { + 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) -> i32 { println!("Called: managed_scalar_mult_ec"); 0 } - fn marshal_ec(&self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32 { + fn marshal_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32 { println!("Called: marshal_ec"); 0 } - fn managed_marshal_ec(&self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { + fn managed_marshal_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { println!("Called: managed_marshal_ec"); 0 } - fn marshal_compressed_ec(&self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32 { + fn marshal_compressed_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32 { println!("Called: marshal_compressed_ec"); 0 } - fn managed_marshal_compressed_ec(&self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { + fn managed_marshal_compressed_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { println!("Called: managed_marshal_compressed_ec"); 0 } - fn unmarshal_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32 { + fn unmarshal_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32 { println!("Called: unmarshal_ec"); 0 } - fn managed_unmarshal_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { + fn managed_unmarshal_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { println!("Called: managed_unmarshal_ec"); 0 } - fn unmarshal_compressed_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32 { + fn unmarshal_compressed_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> i32 { println!("Called: unmarshal_compressed_ec"); 0 } - fn managed_unmarshal_compressed_ec(&self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { + fn managed_unmarshal_compressed_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> i32 { println!("Called: managed_unmarshal_compressed_ec"); 0 } - fn generate_key_ec(&self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32 { + fn generate_key_ec(&mut self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_offset: MemPtr) -> i32 { println!("Called: generate_key_ec"); 0 } - fn managed_generate_key_ec(&self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { + fn managed_generate_key_ec(&mut self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_handle: i32) -> i32 { println!("Called: managed_generate_key_ec"); 0 } - fn create_ec(&self, data_offset: MemPtr, data_length: MemLength) -> i32 { + fn create_ec(&mut self, data_offset: MemPtr, data_length: MemLength) -> i32 { println!("Called: create_ec"); 0 } - fn managed_create_ec(&self, data_handle: i32) -> i32 { + fn managed_create_ec(&mut self, data_handle: i32) -> i32 { println!("Called: managed_create_ec"); 0 } - fn get_curve_length_ec(&self, ec_handle: i32) -> i32 { + fn get_curve_length_ec(&mut self, ec_handle: i32) -> i32 { println!("Called: get_curve_length_ec"); 0 } - fn get_priv_key_byte_length_ec(&self, ec_handle: i32) -> i32 { + fn get_priv_key_byte_length_ec(&mut self, ec_handle: i32) -> i32 { println!("Called: get_priv_key_byte_length_ec"); 0 } - fn elliptic_curve_get_values(&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) -> i32 { + 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) -> i32 { println!("Called: elliptic_curve_get_values"); 0 } - fn managed_verify_secp256r1(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { + fn managed_verify_secp256r1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { println!("Called: managed_verify_secp256r1"); 0 } - fn managed_verify_blssignature_share(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { + fn managed_verify_blssignature_share(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { println!("Called: managed_verify_blssignature_share"); 0 } - fn managed_verify_blsaggregated_signature(&self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { + fn managed_verify_blsaggregated_signature(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> i32 { println!("Called: managed_verify_blsaggregated_signature"); 0 } diff --git a/vm-executor/src/vm_hooks_new.rs b/vm-executor/src/vm_hooks_new.rs new file mode 100644 index 0000000..efe528d --- /dev/null +++ b/vm-executor/src/vm_hooks_new.rs @@ -0,0 +1,1594 @@ +// Code generated by vmhooks generator. DO NOT EDIT. + +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +// !!!!!!!!!!!!!!!!!!!!!! AUTO-GENERATED FILE !!!!!!!!!!!!!!!!!!!!!! +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +use crate::{BreakpointValue, MemLength, MemPtr}; + +pub type VMHooksError = BreakpointValue; + +#[rustfmt::skip] +#[allow(clippy::too_many_arguments)] +pub trait VMHooks: core::fmt::Debug { + fn get_gas_left(&mut self) -> Result; + fn get_sc_address(&mut self, result_offset: MemPtr) -> Result<(), VMHooksError>; + fn get_owner_address(&mut self, result_offset: MemPtr) -> Result<(), VMHooksError>; + fn get_shard_of_address(&mut self, address_offset: MemPtr) -> Result; + fn is_smart_contract(&mut self, address_offset: MemPtr) -> Result; + fn signal_error(&mut self, message_offset: MemPtr, message_length: MemLength) -> Result<(), VMHooksError>; + fn get_external_balance(&mut self, address_offset: MemPtr, result_offset: MemPtr) -> Result<(), VMHooksError>; + fn get_block_hash(&mut self, nonce: i64, result_offset: MemPtr) -> Result; + fn get_esdt_balance(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, result_offset: MemPtr) -> Result; + fn get_esdt_nft_name_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> Result; + fn get_esdt_nft_attribute_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> Result; + fn get_esdt_nft_uri_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> Result; + 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; + fn get_esdt_local_roles(&mut self, token_id_handle: i32) -> Result; + fn validate_token_identifier(&mut self, token_id_handle: i32) -> Result; + fn transfer_value(&mut self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength) -> Result; + 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; + 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; + 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; + 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; + 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; + fn set_async_context_callback(&mut self, callback: MemPtr, callback_length: MemLength, data: MemPtr, data_length: MemLength, gas: i64) -> Result; + 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<(), VMHooksError>; + 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<(), VMHooksError>; + fn delete_contract(&mut self, dest_offset: MemPtr, gas_limit: i64, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr) -> Result<(), VMHooksError>; + fn async_call(&mut self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength) -> Result<(), VMHooksError>; + fn get_argument_length(&mut self, id: i32) -> Result; + fn get_argument(&mut self, id: i32, arg_offset: MemPtr) -> Result; + fn get_function(&mut self, function_offset: MemPtr) -> Result; + fn get_num_arguments(&mut self) -> Result; + fn storage_store(&mut self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr, data_length: MemLength) -> Result; + fn storage_load_length(&mut self, key_offset: MemPtr, key_length: MemLength) -> Result; + fn storage_load_from_address(&mut self, address_offset: MemPtr, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> Result; + fn storage_load(&mut self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> Result; + fn set_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength, lock_timestamp: i64) -> Result; + fn get_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength) -> Result; + fn is_storage_locked(&mut self, key_offset: MemPtr, key_length: MemLength) -> Result; + fn clear_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength) -> Result; + fn get_caller(&mut self, result_offset: MemPtr) -> Result<(), VMHooksError>; + fn check_no_payment(&mut self) -> Result<(), VMHooksError>; + fn get_call_value(&mut self, result_offset: MemPtr) -> Result; + fn get_esdt_value(&mut self, result_offset: MemPtr) -> Result; + fn get_esdt_value_by_index(&mut self, result_offset: MemPtr, index: i32) -> Result; + fn get_esdt_token_name(&mut self, result_offset: MemPtr) -> Result; + fn get_esdt_token_name_by_index(&mut self, result_offset: MemPtr, index: i32) -> Result; + fn get_esdt_token_nonce(&mut self) -> Result; + fn get_esdt_token_nonce_by_index(&mut self, index: i32) -> Result; + fn get_current_esdt_nft_nonce(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength) -> Result; + fn get_esdt_token_type(&mut self) -> Result; + fn get_esdt_token_type_by_index(&mut self, index: i32) -> Result; + fn get_num_esdt_transfers(&mut self) -> Result; + fn get_call_value_token_name(&mut self, call_value_offset: MemPtr, token_name_offset: MemPtr) -> Result; + fn get_call_value_token_name_by_index(&mut self, call_value_offset: MemPtr, token_name_offset: MemPtr, index: i32) -> Result; + fn is_reserved_function_name(&mut self, name_handle: i32) -> Result; + fn write_log(&mut self, data_pointer: MemPtr, data_length: MemLength, topic_ptr: MemPtr, num_topics: i32) -> Result<(), VMHooksError>; + fn write_event_log(&mut self, num_topics: i32, topic_lengths_offset: MemPtr, topic_offset: MemPtr, data_offset: MemPtr, data_length: MemLength) -> Result<(), VMHooksError>; + fn get_block_timestamp(&mut self) -> Result; + fn get_block_nonce(&mut self) -> Result; + fn get_block_round(&mut self) -> Result; + fn get_block_epoch(&mut self) -> Result; + fn get_block_random_seed(&mut self, pointer: MemPtr) -> Result<(), VMHooksError>; + fn get_state_root_hash(&mut self, pointer: MemPtr) -> Result<(), VMHooksError>; + fn get_prev_block_timestamp(&mut self) -> Result; + fn get_prev_block_nonce(&mut self) -> Result; + fn get_prev_block_round(&mut self) -> Result; + fn get_prev_block_epoch(&mut self) -> Result; + fn get_prev_block_random_seed(&mut self, pointer: MemPtr) -> Result<(), VMHooksError>; + fn finish(&mut self, pointer: MemPtr, length: MemLength) -> Result<(), VMHooksError>; + 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; + 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; + 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; + 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; + 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; + fn get_num_return_data(&mut self) -> Result; + fn get_return_data_size(&mut self, result_id: i32) -> Result; + fn get_return_data(&mut self, result_id: i32, data_offset: MemPtr) -> Result; + fn clean_return_data(&mut self) -> Result<(), VMHooksError>; + fn delete_from_return_data(&mut self, result_id: i32) -> Result<(), VMHooksError>; + fn get_original_tx_hash(&mut self, data_offset: MemPtr) -> Result<(), VMHooksError>; + fn get_current_tx_hash(&mut self, data_offset: MemPtr) -> Result<(), VMHooksError>; + fn get_prev_tx_hash(&mut self, data_offset: MemPtr) -> Result<(), VMHooksError>; + fn managed_sc_address(&mut self, destination_handle: i32) -> Result<(), VMHooksError>; + fn managed_owner_address(&mut self, destination_handle: i32) -> Result<(), VMHooksError>; + fn managed_caller(&mut self, destination_handle: i32) -> Result<(), VMHooksError>; + fn managed_get_original_caller_addr(&mut self, destination_handle: i32) -> Result<(), VMHooksError>; + fn managed_get_relayer_addr(&mut self, destination_handle: i32) -> Result<(), VMHooksError>; + fn managed_signal_error(&mut self, err_handle: i32) -> Result<(), VMHooksError>; + fn managed_write_log(&mut self, topics_handle: i32, data_handle: i32) -> Result<(), VMHooksError>; + fn managed_get_original_tx_hash(&mut self, result_handle: i32) -> Result<(), VMHooksError>; + fn managed_get_state_root_hash(&mut self, result_handle: i32) -> Result<(), VMHooksError>; + fn managed_get_block_random_seed(&mut self, result_handle: i32) -> Result<(), VMHooksError>; + fn managed_get_prev_block_random_seed(&mut self, result_handle: i32) -> Result<(), VMHooksError>; + fn managed_get_return_data(&mut self, result_id: i32, result_handle: i32) -> Result<(), VMHooksError>; + fn managed_get_multi_esdt_call_value(&mut self, multi_call_value_handle: i32) -> Result<(), VMHooksError>; + fn managed_get_back_transfers(&mut self, esdt_transfers_value_handle: i32, egld_value_handle: i32) -> Result<(), VMHooksError>; + fn managed_get_esdt_balance(&mut self, address_handle: i32, token_id_handle: i32, nonce: i64, value_handle: i32) -> Result<(), VMHooksError>; + 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<(), VMHooksError>; + fn managed_async_call(&mut self, dest_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32) -> Result<(), VMHooksError>; + 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; + fn managed_get_callback_closure(&mut self, callback_closure_handle: i32) -> Result<(), VMHooksError>; + 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<(), VMHooksError>; + 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<(), VMHooksError>; + fn managed_delete_contract(&mut self, dest_handle: i32, gas_limit: i64, arguments_handle: i32) -> Result<(), VMHooksError>; + 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; + 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; + fn managed_execute_read_only(&mut self, gas: i64, address_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> Result; + 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; + 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; + 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; + 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; + fn managed_transfer_value_execute(&mut self, dst_handle: i32, value_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> Result; + fn managed_is_esdt_frozen(&mut self, address_handle: i32, token_id_handle: i32, nonce: i64) -> Result; + fn managed_is_esdt_limited_transfer(&mut self, token_id_handle: i32) -> Result; + fn managed_is_esdt_paused(&mut self, token_id_handle: i32) -> Result; + fn managed_buffer_to_hex(&mut self, source_handle: i32, dest_handle: i32) -> Result<(), VMHooksError>; + fn managed_get_code_metadata(&mut self, address_handle: i32, response_handle: i32) -> Result<(), VMHooksError>; + fn managed_is_builtin_function(&mut self, function_name_handle: i32) -> Result; + fn big_float_new_from_parts(&mut self, integral_part: i32, fractional_part: i32, exponent: i32) -> Result; + fn big_float_new_from_frac(&mut self, numerator: i64, denominator: i64) -> Result; + fn big_float_new_from_sci(&mut self, significand: i64, exponent: i64) -> Result; + fn big_float_add(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_float_sub(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_float_mul(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_float_div(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_float_neg(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError>; + fn big_float_clone(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError>; + fn big_float_cmp(&mut self, op1_handle: i32, op2_handle: i32) -> Result; + fn big_float_abs(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError>; + fn big_float_sign(&mut self, op_handle: i32) -> Result; + fn big_float_sqrt(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError>; + fn big_float_pow(&mut self, destination_handle: i32, op_handle: i32, exponent: i32) -> Result<(), VMHooksError>; + fn big_float_floor(&mut self, dest_big_int_handle: i32, op_handle: i32) -> Result<(), VMHooksError>; + fn big_float_ceil(&mut self, dest_big_int_handle: i32, op_handle: i32) -> Result<(), VMHooksError>; + fn big_float_truncate(&mut self, dest_big_int_handle: i32, op_handle: i32) -> Result<(), VMHooksError>; + fn big_float_set_int64(&mut self, destination_handle: i32, value: i64) -> Result<(), VMHooksError>; + fn big_float_is_int(&mut self, op_handle: i32) -> Result; + fn big_float_set_big_int(&mut self, destination_handle: i32, big_int_handle: i32) -> Result<(), VMHooksError>; + fn big_float_get_const_pi(&mut self, destination_handle: i32) -> Result<(), VMHooksError>; + fn big_float_get_const_e(&mut self, destination_handle: i32) -> Result<(), VMHooksError>; + fn big_int_get_unsigned_argument(&mut self, id: i32, destination_handle: i32) -> Result<(), VMHooksError>; + fn big_int_get_signed_argument(&mut self, id: i32, destination_handle: i32) -> Result<(), VMHooksError>; + fn big_int_storage_store_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, source_handle: i32) -> Result; + fn big_int_storage_load_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, destination_handle: i32) -> Result; + fn big_int_get_call_value(&mut self, destination_handle: i32) -> Result<(), VMHooksError>; + fn big_int_get_esdt_call_value(&mut self, destination: i32) -> Result<(), VMHooksError>; + fn big_int_get_esdt_call_value_by_index(&mut self, destination_handle: i32, index: i32) -> Result<(), VMHooksError>; + fn big_int_get_external_balance(&mut self, address_offset: MemPtr, result: i32) -> Result<(), VMHooksError>; + 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<(), VMHooksError>; + fn big_int_new(&mut self, small_value: i64) -> Result; + fn big_int_unsigned_byte_length(&mut self, reference_handle: i32) -> Result; + fn big_int_signed_byte_length(&mut self, reference_handle: i32) -> Result; + fn big_int_get_unsigned_bytes(&mut self, reference_handle: i32, byte_offset: MemPtr) -> Result; + fn big_int_get_signed_bytes(&mut self, reference_handle: i32, byte_offset: MemPtr) -> Result; + fn big_int_set_unsigned_bytes(&mut self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength) -> Result<(), VMHooksError>; + fn big_int_set_signed_bytes(&mut self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength) -> Result<(), VMHooksError>; + fn big_int_is_int64(&mut self, destination_handle: i32) -> Result; + fn big_int_get_int64(&mut self, destination_handle: i32) -> Result; + fn big_int_set_int64(&mut self, destination_handle: i32, value: i64) -> Result<(), VMHooksError>; + fn big_int_add(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_int_sub(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_int_mul(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_int_tdiv(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_int_tmod(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_int_ediv(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_int_emod(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_int_sqrt(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError>; + fn big_int_pow(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_int_log2(&mut self, op1_handle: i32) -> Result; + fn big_int_abs(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError>; + fn big_int_neg(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError>; + fn big_int_sign(&mut self, op_handle: i32) -> Result; + fn big_int_cmp(&mut self, op1_handle: i32, op2_handle: i32) -> Result; + fn big_int_not(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError>; + fn big_int_and(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_int_or(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_int_xor(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError>; + fn big_int_shr(&mut self, destination_handle: i32, op_handle: i32, bits: i32) -> Result<(), VMHooksError>; + fn big_int_shl(&mut self, destination_handle: i32, op_handle: i32, bits: i32) -> Result<(), VMHooksError>; + fn big_int_finish_unsigned(&mut self, reference_handle: i32) -> Result<(), VMHooksError>; + fn big_int_finish_signed(&mut self, reference_handle: i32) -> Result<(), VMHooksError>; + fn big_int_to_string(&mut self, big_int_handle: i32, destination_handle: i32) -> Result<(), VMHooksError>; + fn mbuffer_new(&mut self) -> Result; + fn mbuffer_new_from_bytes(&mut self, data_offset: MemPtr, data_length: MemLength) -> Result; + fn mbuffer_get_length(&mut self, m_buffer_handle: i32) -> Result; + fn mbuffer_get_bytes(&mut self, m_buffer_handle: i32, result_offset: MemPtr) -> Result; + fn mbuffer_get_byte_slice(&mut self, source_handle: i32, starting_position: i32, slice_length: i32, result_offset: MemPtr) -> Result; + fn mbuffer_copy_byte_slice(&mut self, source_handle: i32, starting_position: i32, slice_length: i32, destination_handle: i32) -> Result; + fn mbuffer_eq(&mut self, m_buffer_handle1: i32, m_buffer_handle2: i32) -> Result; + fn mbuffer_set_bytes(&mut self, m_buffer_handle: i32, data_offset: MemPtr, data_length: MemLength) -> Result; + fn mbuffer_set_byte_slice(&mut self, m_buffer_handle: i32, starting_position: i32, data_length: MemLength, data_offset: MemPtr) -> Result; + fn mbuffer_append(&mut self, accumulator_handle: i32, data_handle: i32) -> Result; + fn mbuffer_append_bytes(&mut self, accumulator_handle: i32, data_offset: MemPtr, data_length: MemLength) -> Result; + fn mbuffer_to_big_int_unsigned(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> Result; + fn mbuffer_to_big_int_signed(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> Result; + fn mbuffer_from_big_int_unsigned(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> Result; + fn mbuffer_from_big_int_signed(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> Result; + fn mbuffer_to_big_float(&mut self, m_buffer_handle: i32, big_float_handle: i32) -> Result; + fn mbuffer_from_big_float(&mut self, m_buffer_handle: i32, big_float_handle: i32) -> Result; + fn mbuffer_storage_store(&mut self, key_handle: i32, source_handle: i32) -> Result; + fn mbuffer_storage_load(&mut self, key_handle: i32, destination_handle: i32) -> Result; + fn mbuffer_storage_load_from_address(&mut self, address_handle: i32, key_handle: i32, destination_handle: i32) -> Result<(), VMHooksError>; + fn mbuffer_get_argument(&mut self, id: i32, destination_handle: i32) -> Result; + fn mbuffer_finish(&mut self, source_handle: i32) -> Result; + fn mbuffer_set_random(&mut self, destination_handle: i32, length: i32) -> Result; + fn managed_map_new(&mut self) -> Result; + fn managed_map_put(&mut self, m_map_handle: i32, key_handle: i32, value_handle: i32) -> Result; + fn managed_map_get(&mut self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> Result; + fn managed_map_remove(&mut self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> Result; + fn managed_map_contains(&mut self, m_map_handle: i32, key_handle: i32) -> Result; + fn small_int_get_unsigned_argument(&mut self, id: i32) -> Result; + fn small_int_get_signed_argument(&mut self, id: i32) -> Result; + fn small_int_finish_unsigned(&mut self, value: i64) -> Result<(), VMHooksError>; + fn small_int_finish_signed(&mut self, value: i64) -> Result<(), VMHooksError>; + fn small_int_storage_store_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> Result; + fn small_int_storage_store_signed(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> Result; + fn small_int_storage_load_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength) -> Result; + fn small_int_storage_load_signed(&mut self, key_offset: MemPtr, key_length: MemLength) -> Result; + fn int64get_argument(&mut self, id: i32) -> Result; + fn int64finish(&mut self, value: i64) -> Result<(), VMHooksError>; + fn int64storage_store(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> Result; + fn int64storage_load(&mut self, key_offset: MemPtr, key_length: MemLength) -> Result; + fn sha256(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> Result; + fn managed_sha256(&mut self, input_handle: i32, output_handle: i32) -> Result; + fn keccak256(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> Result; + fn managed_keccak256(&mut self, input_handle: i32, output_handle: i32) -> Result; + fn ripemd160(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> Result; + fn managed_ripemd160(&mut self, input_handle: i32, output_handle: i32) -> Result; + fn verify_bls(&mut self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> Result; + fn managed_verify_bls(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result; + fn verify_ed25519(&mut self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> Result; + fn managed_verify_ed25519(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result; + 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; + fn managed_verify_custom_secp256k1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32, hash_type: i32) -> Result; + fn verify_secp256k1(&mut self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> Result; + fn managed_verify_secp256k1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result; + fn encode_secp256k1_der_signature(&mut self, r_offset: MemPtr, r_length: MemLength, s_offset: MemPtr, s_length: MemLength, sig_offset: MemPtr) -> Result; + fn managed_encode_secp256k1_der_signature(&mut self, r_handle: i32, s_handle: i32, sig_handle: i32) -> Result; + 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<(), VMHooksError>; + fn double_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) -> Result<(), VMHooksError>; + fn is_on_curve_ec(&mut self, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) -> Result; + fn scalar_base_mult_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> Result; + fn managed_scalar_base_mult_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> Result; + 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; + 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; + fn marshal_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> Result; + fn managed_marshal_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> Result; + fn marshal_compressed_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> Result; + fn managed_marshal_compressed_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> Result; + fn unmarshal_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> Result; + fn managed_unmarshal_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> Result; + fn unmarshal_compressed_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> Result; + fn managed_unmarshal_compressed_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> Result; + fn generate_key_ec(&mut self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_offset: MemPtr) -> Result; + fn managed_generate_key_ec(&mut self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_handle: i32) -> Result; + fn create_ec(&mut self, data_offset: MemPtr, data_length: MemLength) -> Result; + fn managed_create_ec(&mut self, data_handle: i32) -> Result; + fn get_curve_length_ec(&mut self, ec_handle: i32) -> Result; + fn get_priv_key_byte_length_ec(&mut self, ec_handle: i32) -> Result; + 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; + fn managed_verify_secp256r1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result; + fn managed_verify_blssignature_share(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result; + fn managed_verify_blsaggregated_signature(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result; +} + +/// Dummy implementation for VMHooks. Can be used as placeholder, or in tests. +#[derive(Debug)] +pub struct VMHooksDefault; + +#[allow(unused)] +#[rustfmt::skip] +impl VMHooks for VMHooksDefault { + fn get_gas_left(&mut self) -> Result { + println!("Called: get_gas_left"); + Ok(0) + } + + fn get_sc_address(&mut self, result_offset: MemPtr) -> Result<(), VMHooksError> { + println!("Called: get_sc_address"); + Ok(()) + } + + fn get_owner_address(&mut self, result_offset: MemPtr) -> Result<(), VMHooksError> { + println!("Called: get_owner_address"); + Ok(()) + } + + fn get_shard_of_address(&mut self, address_offset: MemPtr) -> Result { + println!("Called: get_shard_of_address"); + Ok(0) + } + + fn is_smart_contract(&mut self, address_offset: MemPtr) -> Result { + println!("Called: is_smart_contract"); + Ok(0) + } + + fn signal_error(&mut self, message_offset: MemPtr, message_length: MemLength) -> Result<(), VMHooksError> { + println!("Called: signal_error"); + Ok(()) + } + + fn get_external_balance(&mut self, address_offset: MemPtr, result_offset: MemPtr) -> Result<(), VMHooksError> { + println!("Called: get_external_balance"); + Ok(()) + } + + fn get_block_hash(&mut self, nonce: i64, result_offset: MemPtr) -> Result { + println!("Called: get_block_hash"); + Ok(0) + } + + fn get_esdt_balance(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64, result_offset: MemPtr) -> Result { + println!("Called: get_esdt_balance"); + Ok(0) + } + + fn get_esdt_nft_name_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> Result { + println!("Called: get_esdt_nft_name_length"); + Ok(0) + } + + fn get_esdt_nft_attribute_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> Result { + println!("Called: get_esdt_nft_attribute_length"); + Ok(0) + } + + fn get_esdt_nft_uri_length(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength, nonce: i64) -> Result { + println!("Called: get_esdt_nft_uri_length"); + Ok(0) + } + + 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 { + println!("Called: get_esdt_token_data"); + Ok(0) + } + + fn get_esdt_local_roles(&mut self, token_id_handle: i32) -> Result { + println!("Called: get_esdt_local_roles"); + Ok(0) + } + + fn validate_token_identifier(&mut self, token_id_handle: i32) -> Result { + println!("Called: validate_token_identifier"); + Ok(0) + } + + fn transfer_value(&mut self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength) -> Result { + println!("Called: transfer_value"); + Ok(0) + } + + 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 { + println!("Called: transfer_value_execute"); + Ok(0) + } + + 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 { + println!("Called: transfer_esdt_execute"); + Ok(0) + } + + 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 { + println!("Called: transfer_esdt_nft_execute"); + Ok(0) + } + + 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 { + println!("Called: multi_transfer_esdt_nft_execute"); + Ok(0) + } + + 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 { + println!("Called: create_async_call"); + Ok(0) + } + + fn set_async_context_callback(&mut self, callback: MemPtr, callback_length: MemLength, data: MemPtr, data_length: MemLength, gas: i64) -> Result { + println!("Called: set_async_context_callback"); + Ok(0) + } + + 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<(), VMHooksError> { + println!("Called: upgrade_contract"); + Ok(()) + } + + 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<(), VMHooksError> { + println!("Called: upgrade_from_source_contract"); + Ok(()) + } + + fn delete_contract(&mut self, dest_offset: MemPtr, gas_limit: i64, num_arguments: i32, arguments_length_offset: MemPtr, data_offset: MemPtr) -> Result<(), VMHooksError> { + println!("Called: delete_contract"); + Ok(()) + } + + fn async_call(&mut self, dest_offset: MemPtr, value_offset: MemPtr, data_offset: MemPtr, length: MemLength) -> Result<(), VMHooksError> { + println!("Called: async_call"); + Ok(()) + } + + fn get_argument_length(&mut self, id: i32) -> Result { + println!("Called: get_argument_length"); + Ok(0) + } + + fn get_argument(&mut self, id: i32, arg_offset: MemPtr) -> Result { + println!("Called: get_argument"); + Ok(0) + } + + fn get_function(&mut self, function_offset: MemPtr) -> Result { + println!("Called: get_function"); + Ok(0) + } + + fn get_num_arguments(&mut self) -> Result { + println!("Called: get_num_arguments"); + Ok(0) + } + + fn storage_store(&mut self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr, data_length: MemLength) -> Result { + println!("Called: storage_store"); + Ok(0) + } + + fn storage_load_length(&mut self, key_offset: MemPtr, key_length: MemLength) -> Result { + println!("Called: storage_load_length"); + Ok(0) + } + + fn storage_load_from_address(&mut self, address_offset: MemPtr, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> Result { + println!("Called: storage_load_from_address"); + Ok(0) + } + + fn storage_load(&mut self, key_offset: MemPtr, key_length: MemLength, data_offset: MemPtr) -> Result { + println!("Called: storage_load"); + Ok(0) + } + + fn set_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength, lock_timestamp: i64) -> Result { + println!("Called: set_storage_lock"); + Ok(0) + } + + fn get_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength) -> Result { + println!("Called: get_storage_lock"); + Ok(0) + } + + fn is_storage_locked(&mut self, key_offset: MemPtr, key_length: MemLength) -> Result { + println!("Called: is_storage_locked"); + Ok(0) + } + + fn clear_storage_lock(&mut self, key_offset: MemPtr, key_length: MemLength) -> Result { + println!("Called: clear_storage_lock"); + Ok(0) + } + + fn get_caller(&mut self, result_offset: MemPtr) -> Result<(), VMHooksError> { + println!("Called: get_caller"); + Ok(()) + } + + fn check_no_payment(&mut self) -> Result<(), VMHooksError> { + println!("Called: check_no_payment"); + Ok(()) + } + + fn get_call_value(&mut self, result_offset: MemPtr) -> Result { + println!("Called: get_call_value"); + Ok(0) + } + + fn get_esdt_value(&mut self, result_offset: MemPtr) -> Result { + println!("Called: get_esdt_value"); + Ok(0) + } + + fn get_esdt_value_by_index(&mut self, result_offset: MemPtr, index: i32) -> Result { + println!("Called: get_esdt_value_by_index"); + Ok(0) + } + + fn get_esdt_token_name(&mut self, result_offset: MemPtr) -> Result { + println!("Called: get_esdt_token_name"); + Ok(0) + } + + fn get_esdt_token_name_by_index(&mut self, result_offset: MemPtr, index: i32) -> Result { + println!("Called: get_esdt_token_name_by_index"); + Ok(0) + } + + fn get_esdt_token_nonce(&mut self) -> Result { + println!("Called: get_esdt_token_nonce"); + Ok(0) + } + + fn get_esdt_token_nonce_by_index(&mut self, index: i32) -> Result { + println!("Called: get_esdt_token_nonce_by_index"); + Ok(0) + } + + fn get_current_esdt_nft_nonce(&mut self, address_offset: MemPtr, token_id_offset: MemPtr, token_id_len: MemLength) -> Result { + println!("Called: get_current_esdt_nft_nonce"); + Ok(0) + } + + fn get_esdt_token_type(&mut self) -> Result { + println!("Called: get_esdt_token_type"); + Ok(0) + } + + fn get_esdt_token_type_by_index(&mut self, index: i32) -> Result { + println!("Called: get_esdt_token_type_by_index"); + Ok(0) + } + + fn get_num_esdt_transfers(&mut self) -> Result { + println!("Called: get_num_esdt_transfers"); + Ok(0) + } + + fn get_call_value_token_name(&mut self, call_value_offset: MemPtr, token_name_offset: MemPtr) -> Result { + println!("Called: get_call_value_token_name"); + Ok(0) + } + + fn get_call_value_token_name_by_index(&mut self, call_value_offset: MemPtr, token_name_offset: MemPtr, index: i32) -> Result { + println!("Called: get_call_value_token_name_by_index"); + Ok(0) + } + + fn is_reserved_function_name(&mut self, name_handle: i32) -> Result { + println!("Called: is_reserved_function_name"); + Ok(0) + } + + fn write_log(&mut self, data_pointer: MemPtr, data_length: MemLength, topic_ptr: MemPtr, num_topics: i32) -> Result<(), VMHooksError> { + println!("Called: write_log"); + Ok(()) + } + + fn write_event_log(&mut self, num_topics: i32, topic_lengths_offset: MemPtr, topic_offset: MemPtr, data_offset: MemPtr, data_length: MemLength) -> Result<(), VMHooksError> { + println!("Called: write_event_log"); + Ok(()) + } + + fn get_block_timestamp(&mut self) -> Result { + println!("Called: get_block_timestamp"); + Ok(0) + } + + fn get_block_nonce(&mut self) -> Result { + println!("Called: get_block_nonce"); + Ok(0) + } + + fn get_block_round(&mut self) -> Result { + println!("Called: get_block_round"); + Ok(0) + } + + fn get_block_epoch(&mut self) -> Result { + println!("Called: get_block_epoch"); + Ok(0) + } + + fn get_block_random_seed(&mut self, pointer: MemPtr) -> Result<(), VMHooksError> { + println!("Called: get_block_random_seed"); + Ok(()) + } + + fn get_state_root_hash(&mut self, pointer: MemPtr) -> Result<(), VMHooksError> { + println!("Called: get_state_root_hash"); + Ok(()) + } + + fn get_prev_block_timestamp(&mut self) -> Result { + println!("Called: get_prev_block_timestamp"); + Ok(0) + } + + fn get_prev_block_nonce(&mut self) -> Result { + println!("Called: get_prev_block_nonce"); + Ok(0) + } + + fn get_prev_block_round(&mut self) -> Result { + println!("Called: get_prev_block_round"); + Ok(0) + } + + fn get_prev_block_epoch(&mut self) -> Result { + println!("Called: get_prev_block_epoch"); + Ok(0) + } + + fn get_prev_block_random_seed(&mut self, pointer: MemPtr) -> Result<(), VMHooksError> { + println!("Called: get_prev_block_random_seed"); + Ok(()) + } + + fn finish(&mut self, pointer: MemPtr, length: MemLength) -> Result<(), VMHooksError> { + println!("Called: finish"); + Ok(()) + } + + 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 { + println!("Called: execute_on_same_context"); + Ok(0) + } + + 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 { + println!("Called: execute_on_dest_context"); + Ok(0) + } + + 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 { + println!("Called: execute_read_only"); + Ok(0) + } + + 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 { + println!("Called: create_contract"); + Ok(0) + } + + 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 { + println!("Called: deploy_from_source_contract"); + Ok(0) + } + + fn get_num_return_data(&mut self) -> Result { + println!("Called: get_num_return_data"); + Ok(0) + } + + fn get_return_data_size(&mut self, result_id: i32) -> Result { + println!("Called: get_return_data_size"); + Ok(0) + } + + fn get_return_data(&mut self, result_id: i32, data_offset: MemPtr) -> Result { + println!("Called: get_return_data"); + Ok(0) + } + + fn clean_return_data(&mut self) -> Result<(), VMHooksError> { + println!("Called: clean_return_data"); + Ok(()) + } + + fn delete_from_return_data(&mut self, result_id: i32) -> Result<(), VMHooksError> { + println!("Called: delete_from_return_data"); + Ok(()) + } + + fn get_original_tx_hash(&mut self, data_offset: MemPtr) -> Result<(), VMHooksError> { + println!("Called: get_original_tx_hash"); + Ok(()) + } + + fn get_current_tx_hash(&mut self, data_offset: MemPtr) -> Result<(), VMHooksError> { + println!("Called: get_current_tx_hash"); + Ok(()) + } + + fn get_prev_tx_hash(&mut self, data_offset: MemPtr) -> Result<(), VMHooksError> { + println!("Called: get_prev_tx_hash"); + Ok(()) + } + + fn managed_sc_address(&mut self, destination_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_sc_address"); + Ok(()) + } + + fn managed_owner_address(&mut self, destination_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_owner_address"); + Ok(()) + } + + fn managed_caller(&mut self, destination_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_caller"); + Ok(()) + } + + fn managed_get_original_caller_addr(&mut self, destination_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_get_original_caller_addr"); + Ok(()) + } + + fn managed_get_relayer_addr(&mut self, destination_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_get_relayer_addr"); + Ok(()) + } + + fn managed_signal_error(&mut self, err_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_signal_error"); + Ok(()) + } + + fn managed_write_log(&mut self, topics_handle: i32, data_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_write_log"); + Ok(()) + } + + fn managed_get_original_tx_hash(&mut self, result_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_get_original_tx_hash"); + Ok(()) + } + + fn managed_get_state_root_hash(&mut self, result_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_get_state_root_hash"); + Ok(()) + } + + fn managed_get_block_random_seed(&mut self, result_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_get_block_random_seed"); + Ok(()) + } + + fn managed_get_prev_block_random_seed(&mut self, result_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_get_prev_block_random_seed"); + Ok(()) + } + + fn managed_get_return_data(&mut self, result_id: i32, result_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_get_return_data"); + Ok(()) + } + + fn managed_get_multi_esdt_call_value(&mut self, multi_call_value_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_get_multi_esdt_call_value"); + Ok(()) + } + + fn managed_get_back_transfers(&mut self, esdt_transfers_value_handle: i32, egld_value_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_get_back_transfers"); + Ok(()) + } + + fn managed_get_esdt_balance(&mut self, address_handle: i32, token_id_handle: i32, nonce: i64, value_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_get_esdt_balance"); + Ok(()) + } + + 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<(), VMHooksError> { + println!("Called: managed_get_esdt_token_data"); + Ok(()) + } + + fn managed_async_call(&mut self, dest_handle: i32, value_handle: i32, function_handle: i32, arguments_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_async_call"); + Ok(()) + } + + 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 { + println!("Called: managed_create_async_call"); + Ok(0) + } + + fn managed_get_callback_closure(&mut self, callback_closure_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_get_callback_closure"); + Ok(()) + } + + 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<(), VMHooksError> { + println!("Called: managed_upgrade_from_source_contract"); + Ok(()) + } + + 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<(), VMHooksError> { + println!("Called: managed_upgrade_contract"); + Ok(()) + } + + fn managed_delete_contract(&mut self, dest_handle: i32, gas_limit: i64, arguments_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_delete_contract"); + Ok(()) + } + + 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 { + println!("Called: managed_deploy_from_source_contract"); + Ok(0) + } + + 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 { + println!("Called: managed_create_contract"); + Ok(0) + } + + fn managed_execute_read_only(&mut self, gas: i64, address_handle: i32, function_handle: i32, arguments_handle: i32, result_handle: i32) -> Result { + println!("Called: managed_execute_read_only"); + Ok(0) + } + + 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 { + println!("Called: managed_execute_on_same_context"); + Ok(0) + } + + 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 { + println!("Called: managed_execute_on_dest_context"); + Ok(0) + } + + 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 { + println!("Called: managed_multi_transfer_esdt_nft_execute"); + Ok(0) + } + + 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 { + println!("Called: managed_multi_transfer_esdt_nft_execute_by_user"); + Ok(0) + } + + fn managed_transfer_value_execute(&mut self, dst_handle: i32, value_handle: i32, gas_limit: i64, function_handle: i32, arguments_handle: i32) -> Result { + println!("Called: managed_transfer_value_execute"); + Ok(0) + } + + fn managed_is_esdt_frozen(&mut self, address_handle: i32, token_id_handle: i32, nonce: i64) -> Result { + println!("Called: managed_is_esdt_frozen"); + Ok(0) + } + + fn managed_is_esdt_limited_transfer(&mut self, token_id_handle: i32) -> Result { + println!("Called: managed_is_esdt_limited_transfer"); + Ok(0) + } + + fn managed_is_esdt_paused(&mut self, token_id_handle: i32) -> Result { + println!("Called: managed_is_esdt_paused"); + Ok(0) + } + + fn managed_buffer_to_hex(&mut self, source_handle: i32, dest_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_buffer_to_hex"); + Ok(()) + } + + fn managed_get_code_metadata(&mut self, address_handle: i32, response_handle: i32) -> Result<(), VMHooksError> { + println!("Called: managed_get_code_metadata"); + Ok(()) + } + + fn managed_is_builtin_function(&mut self, function_name_handle: i32) -> Result { + println!("Called: managed_is_builtin_function"); + Ok(0) + } + + fn big_float_new_from_parts(&mut self, integral_part: i32, fractional_part: i32, exponent: i32) -> Result { + println!("Called: big_float_new_from_parts"); + Ok(0) + } + + fn big_float_new_from_frac(&mut self, numerator: i64, denominator: i64) -> Result { + println!("Called: big_float_new_from_frac"); + Ok(0) + } + + fn big_float_new_from_sci(&mut self, significand: i64, exponent: i64) -> Result { + println!("Called: big_float_new_from_sci"); + Ok(0) + } + + fn big_float_add(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_add"); + Ok(()) + } + + fn big_float_sub(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_sub"); + Ok(()) + } + + fn big_float_mul(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_mul"); + Ok(()) + } + + fn big_float_div(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_div"); + Ok(()) + } + + fn big_float_neg(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_neg"); + Ok(()) + } + + fn big_float_clone(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_clone"); + Ok(()) + } + + fn big_float_cmp(&mut self, op1_handle: i32, op2_handle: i32) -> Result { + println!("Called: big_float_cmp"); + Ok(0) + } + + fn big_float_abs(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_abs"); + Ok(()) + } + + fn big_float_sign(&mut self, op_handle: i32) -> Result { + println!("Called: big_float_sign"); + Ok(0) + } + + fn big_float_sqrt(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_sqrt"); + Ok(()) + } + + fn big_float_pow(&mut self, destination_handle: i32, op_handle: i32, exponent: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_pow"); + Ok(()) + } + + fn big_float_floor(&mut self, dest_big_int_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_floor"); + Ok(()) + } + + fn big_float_ceil(&mut self, dest_big_int_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_ceil"); + Ok(()) + } + + fn big_float_truncate(&mut self, dest_big_int_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_truncate"); + Ok(()) + } + + fn big_float_set_int64(&mut self, destination_handle: i32, value: i64) -> Result<(), VMHooksError> { + println!("Called: big_float_set_int64"); + Ok(()) + } + + fn big_float_is_int(&mut self, op_handle: i32) -> Result { + println!("Called: big_float_is_int"); + Ok(0) + } + + fn big_float_set_big_int(&mut self, destination_handle: i32, big_int_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_set_big_int"); + Ok(()) + } + + fn big_float_get_const_pi(&mut self, destination_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_get_const_pi"); + Ok(()) + } + + fn big_float_get_const_e(&mut self, destination_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_float_get_const_e"); + Ok(()) + } + + fn big_int_get_unsigned_argument(&mut self, id: i32, destination_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_get_unsigned_argument"); + Ok(()) + } + + fn big_int_get_signed_argument(&mut self, id: i32, destination_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_get_signed_argument"); + Ok(()) + } + + fn big_int_storage_store_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, source_handle: i32) -> Result { + println!("Called: big_int_storage_store_unsigned"); + Ok(0) + } + + fn big_int_storage_load_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, destination_handle: i32) -> Result { + println!("Called: big_int_storage_load_unsigned"); + Ok(0) + } + + fn big_int_get_call_value(&mut self, destination_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_get_call_value"); + Ok(()) + } + + fn big_int_get_esdt_call_value(&mut self, destination: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_get_esdt_call_value"); + Ok(()) + } + + fn big_int_get_esdt_call_value_by_index(&mut self, destination_handle: i32, index: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_get_esdt_call_value_by_index"); + Ok(()) + } + + fn big_int_get_external_balance(&mut self, address_offset: MemPtr, result: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_get_external_balance"); + Ok(()) + } + + 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<(), VMHooksError> { + println!("Called: big_int_get_esdt_external_balance"); + Ok(()) + } + + fn big_int_new(&mut self, small_value: i64) -> Result { + println!("Called: big_int_new"); + Ok(0) + } + + fn big_int_unsigned_byte_length(&mut self, reference_handle: i32) -> Result { + println!("Called: big_int_unsigned_byte_length"); + Ok(0) + } + + fn big_int_signed_byte_length(&mut self, reference_handle: i32) -> Result { + println!("Called: big_int_signed_byte_length"); + Ok(0) + } + + fn big_int_get_unsigned_bytes(&mut self, reference_handle: i32, byte_offset: MemPtr) -> Result { + println!("Called: big_int_get_unsigned_bytes"); + Ok(0) + } + + fn big_int_get_signed_bytes(&mut self, reference_handle: i32, byte_offset: MemPtr) -> Result { + println!("Called: big_int_get_signed_bytes"); + Ok(0) + } + + fn big_int_set_unsigned_bytes(&mut self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength) -> Result<(), VMHooksError> { + println!("Called: big_int_set_unsigned_bytes"); + Ok(()) + } + + fn big_int_set_signed_bytes(&mut self, destination_handle: i32, byte_offset: MemPtr, byte_length: MemLength) -> Result<(), VMHooksError> { + println!("Called: big_int_set_signed_bytes"); + Ok(()) + } + + fn big_int_is_int64(&mut self, destination_handle: i32) -> Result { + println!("Called: big_int_is_int64"); + Ok(0) + } + + fn big_int_get_int64(&mut self, destination_handle: i32) -> Result { + println!("Called: big_int_get_int64"); + Ok(0) + } + + fn big_int_set_int64(&mut self, destination_handle: i32, value: i64) -> Result<(), VMHooksError> { + println!("Called: big_int_set_int64"); + Ok(()) + } + + fn big_int_add(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_add"); + Ok(()) + } + + fn big_int_sub(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_sub"); + Ok(()) + } + + fn big_int_mul(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_mul"); + Ok(()) + } + + fn big_int_tdiv(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_tdiv"); + Ok(()) + } + + fn big_int_tmod(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_tmod"); + Ok(()) + } + + fn big_int_ediv(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_ediv"); + Ok(()) + } + + fn big_int_emod(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_emod"); + Ok(()) + } + + fn big_int_sqrt(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_sqrt"); + Ok(()) + } + + fn big_int_pow(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_pow"); + Ok(()) + } + + fn big_int_log2(&mut self, op1_handle: i32) -> Result { + println!("Called: big_int_log2"); + Ok(0) + } + + fn big_int_abs(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_abs"); + Ok(()) + } + + fn big_int_neg(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_neg"); + Ok(()) + } + + fn big_int_sign(&mut self, op_handle: i32) -> Result { + println!("Called: big_int_sign"); + Ok(0) + } + + fn big_int_cmp(&mut self, op1_handle: i32, op2_handle: i32) -> Result { + println!("Called: big_int_cmp"); + Ok(0) + } + + fn big_int_not(&mut self, destination_handle: i32, op_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_not"); + Ok(()) + } + + fn big_int_and(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_and"); + Ok(()) + } + + fn big_int_or(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_or"); + Ok(()) + } + + fn big_int_xor(&mut self, destination_handle: i32, op1_handle: i32, op2_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_xor"); + Ok(()) + } + + fn big_int_shr(&mut self, destination_handle: i32, op_handle: i32, bits: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_shr"); + Ok(()) + } + + fn big_int_shl(&mut self, destination_handle: i32, op_handle: i32, bits: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_shl"); + Ok(()) + } + + fn big_int_finish_unsigned(&mut self, reference_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_finish_unsigned"); + Ok(()) + } + + fn big_int_finish_signed(&mut self, reference_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_finish_signed"); + Ok(()) + } + + fn big_int_to_string(&mut self, big_int_handle: i32, destination_handle: i32) -> Result<(), VMHooksError> { + println!("Called: big_int_to_string"); + Ok(()) + } + + fn mbuffer_new(&mut self) -> Result { + println!("Called: mbuffer_new"); + Ok(0) + } + + fn mbuffer_new_from_bytes(&mut self, data_offset: MemPtr, data_length: MemLength) -> Result { + println!("Called: mbuffer_new_from_bytes"); + Ok(0) + } + + fn mbuffer_get_length(&mut self, m_buffer_handle: i32) -> Result { + println!("Called: mbuffer_get_length"); + Ok(0) + } + + fn mbuffer_get_bytes(&mut self, m_buffer_handle: i32, result_offset: MemPtr) -> Result { + println!("Called: mbuffer_get_bytes"); + Ok(0) + } + + fn mbuffer_get_byte_slice(&mut self, source_handle: i32, starting_position: i32, slice_length: i32, result_offset: MemPtr) -> Result { + println!("Called: mbuffer_get_byte_slice"); + Ok(0) + } + + fn mbuffer_copy_byte_slice(&mut self, source_handle: i32, starting_position: i32, slice_length: i32, destination_handle: i32) -> Result { + println!("Called: mbuffer_copy_byte_slice"); + Ok(0) + } + + fn mbuffer_eq(&mut self, m_buffer_handle1: i32, m_buffer_handle2: i32) -> Result { + println!("Called: mbuffer_eq"); + Ok(0) + } + + fn mbuffer_set_bytes(&mut self, m_buffer_handle: i32, data_offset: MemPtr, data_length: MemLength) -> Result { + println!("Called: mbuffer_set_bytes"); + Ok(0) + } + + fn mbuffer_set_byte_slice(&mut self, m_buffer_handle: i32, starting_position: i32, data_length: MemLength, data_offset: MemPtr) -> Result { + println!("Called: mbuffer_set_byte_slice"); + Ok(0) + } + + fn mbuffer_append(&mut self, accumulator_handle: i32, data_handle: i32) -> Result { + println!("Called: mbuffer_append"); + Ok(0) + } + + fn mbuffer_append_bytes(&mut self, accumulator_handle: i32, data_offset: MemPtr, data_length: MemLength) -> Result { + println!("Called: mbuffer_append_bytes"); + Ok(0) + } + + fn mbuffer_to_big_int_unsigned(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> Result { + println!("Called: mbuffer_to_big_int_unsigned"); + Ok(0) + } + + fn mbuffer_to_big_int_signed(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> Result { + println!("Called: mbuffer_to_big_int_signed"); + Ok(0) + } + + fn mbuffer_from_big_int_unsigned(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> Result { + println!("Called: mbuffer_from_big_int_unsigned"); + Ok(0) + } + + fn mbuffer_from_big_int_signed(&mut self, m_buffer_handle: i32, big_int_handle: i32) -> Result { + println!("Called: mbuffer_from_big_int_signed"); + Ok(0) + } + + fn mbuffer_to_big_float(&mut self, m_buffer_handle: i32, big_float_handle: i32) -> Result { + println!("Called: mbuffer_to_big_float"); + Ok(0) + } + + fn mbuffer_from_big_float(&mut self, m_buffer_handle: i32, big_float_handle: i32) -> Result { + println!("Called: mbuffer_from_big_float"); + Ok(0) + } + + fn mbuffer_storage_store(&mut self, key_handle: i32, source_handle: i32) -> Result { + println!("Called: mbuffer_storage_store"); + Ok(0) + } + + fn mbuffer_storage_load(&mut self, key_handle: i32, destination_handle: i32) -> Result { + println!("Called: mbuffer_storage_load"); + Ok(0) + } + + fn mbuffer_storage_load_from_address(&mut self, address_handle: i32, key_handle: i32, destination_handle: i32) -> Result<(), VMHooksError> { + println!("Called: mbuffer_storage_load_from_address"); + Ok(()) + } + + fn mbuffer_get_argument(&mut self, id: i32, destination_handle: i32) -> Result { + println!("Called: mbuffer_get_argument"); + Ok(0) + } + + fn mbuffer_finish(&mut self, source_handle: i32) -> Result { + println!("Called: mbuffer_finish"); + Ok(0) + } + + fn mbuffer_set_random(&mut self, destination_handle: i32, length: i32) -> Result { + println!("Called: mbuffer_set_random"); + Ok(0) + } + + fn managed_map_new(&mut self) -> Result { + println!("Called: managed_map_new"); + Ok(0) + } + + fn managed_map_put(&mut self, m_map_handle: i32, key_handle: i32, value_handle: i32) -> Result { + println!("Called: managed_map_put"); + Ok(0) + } + + fn managed_map_get(&mut self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> Result { + println!("Called: managed_map_get"); + Ok(0) + } + + fn managed_map_remove(&mut self, m_map_handle: i32, key_handle: i32, out_value_handle: i32) -> Result { + println!("Called: managed_map_remove"); + Ok(0) + } + + fn managed_map_contains(&mut self, m_map_handle: i32, key_handle: i32) -> Result { + println!("Called: managed_map_contains"); + Ok(0) + } + + fn small_int_get_unsigned_argument(&mut self, id: i32) -> Result { + println!("Called: small_int_get_unsigned_argument"); + Ok(0) + } + + fn small_int_get_signed_argument(&mut self, id: i32) -> Result { + println!("Called: small_int_get_signed_argument"); + Ok(0) + } + + fn small_int_finish_unsigned(&mut self, value: i64) -> Result<(), VMHooksError> { + println!("Called: small_int_finish_unsigned"); + Ok(()) + } + + fn small_int_finish_signed(&mut self, value: i64) -> Result<(), VMHooksError> { + println!("Called: small_int_finish_signed"); + Ok(()) + } + + fn small_int_storage_store_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> Result { + println!("Called: small_int_storage_store_unsigned"); + Ok(0) + } + + fn small_int_storage_store_signed(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> Result { + println!("Called: small_int_storage_store_signed"); + Ok(0) + } + + fn small_int_storage_load_unsigned(&mut self, key_offset: MemPtr, key_length: MemLength) -> Result { + println!("Called: small_int_storage_load_unsigned"); + Ok(0) + } + + fn small_int_storage_load_signed(&mut self, key_offset: MemPtr, key_length: MemLength) -> Result { + println!("Called: small_int_storage_load_signed"); + Ok(0) + } + + fn int64get_argument(&mut self, id: i32) -> Result { + println!("Called: int64get_argument"); + Ok(0) + } + + fn int64finish(&mut self, value: i64) -> Result<(), VMHooksError> { + println!("Called: int64finish"); + Ok(()) + } + + fn int64storage_store(&mut self, key_offset: MemPtr, key_length: MemLength, value: i64) -> Result { + println!("Called: int64storage_store"); + Ok(0) + } + + fn int64storage_load(&mut self, key_offset: MemPtr, key_length: MemLength) -> Result { + println!("Called: int64storage_load"); + Ok(0) + } + + fn sha256(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> Result { + println!("Called: sha256"); + Ok(0) + } + + fn managed_sha256(&mut self, input_handle: i32, output_handle: i32) -> Result { + println!("Called: managed_sha256"); + Ok(0) + } + + fn keccak256(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> Result { + println!("Called: keccak256"); + Ok(0) + } + + fn managed_keccak256(&mut self, input_handle: i32, output_handle: i32) -> Result { + println!("Called: managed_keccak256"); + Ok(0) + } + + fn ripemd160(&mut self, data_offset: MemPtr, length: MemLength, result_offset: MemPtr) -> Result { + println!("Called: ripemd160"); + Ok(0) + } + + fn managed_ripemd160(&mut self, input_handle: i32, output_handle: i32) -> Result { + println!("Called: managed_ripemd160"); + Ok(0) + } + + fn verify_bls(&mut self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> Result { + println!("Called: verify_bls"); + Ok(0) + } + + fn managed_verify_bls(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result { + println!("Called: managed_verify_bls"); + Ok(0) + } + + fn verify_ed25519(&mut self, key_offset: MemPtr, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> Result { + println!("Called: verify_ed25519"); + Ok(0) + } + + fn managed_verify_ed25519(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result { + println!("Called: managed_verify_ed25519"); + Ok(0) + } + + 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 { + println!("Called: verify_custom_secp256k1"); + Ok(0) + } + + fn managed_verify_custom_secp256k1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32, hash_type: i32) -> Result { + println!("Called: managed_verify_custom_secp256k1"); + Ok(0) + } + + fn verify_secp256k1(&mut self, key_offset: MemPtr, key_length: MemLength, message_offset: MemPtr, message_length: MemLength, sig_offset: MemPtr) -> Result { + println!("Called: verify_secp256k1"); + Ok(0) + } + + fn managed_verify_secp256k1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result { + println!("Called: managed_verify_secp256k1"); + Ok(0) + } + + fn encode_secp256k1_der_signature(&mut self, r_offset: MemPtr, r_length: MemLength, s_offset: MemPtr, s_length: MemLength, sig_offset: MemPtr) -> Result { + println!("Called: encode_secp256k1_der_signature"); + Ok(0) + } + + fn managed_encode_secp256k1_der_signature(&mut self, r_handle: i32, s_handle: i32, sig_handle: i32) -> Result { + println!("Called: managed_encode_secp256k1_der_signature"); + Ok(0) + } + + 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<(), VMHooksError> { + println!("Called: add_ec"); + Ok(()) + } + + fn double_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) -> Result<(), VMHooksError> { + println!("Called: double_ec"); + Ok(()) + } + + fn is_on_curve_ec(&mut self, ec_handle: i32, point_xhandle: i32, point_yhandle: i32) -> Result { + println!("Called: is_on_curve_ec"); + Ok(0) + } + + fn scalar_base_mult_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> Result { + println!("Called: scalar_base_mult_ec"); + Ok(0) + } + + fn managed_scalar_base_mult_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> Result { + println!("Called: managed_scalar_base_mult_ec"); + Ok(0) + } + + 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 { + println!("Called: scalar_mult_ec"); + Ok(0) + } + + 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 { + println!("Called: managed_scalar_mult_ec"); + Ok(0) + } + + fn marshal_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> Result { + println!("Called: marshal_ec"); + Ok(0) + } + + fn managed_marshal_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> Result { + println!("Called: managed_marshal_ec"); + Ok(0) + } + + fn marshal_compressed_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_offset: MemPtr) -> Result { + println!("Called: marshal_compressed_ec"); + Ok(0) + } + + fn managed_marshal_compressed_ec(&mut self, x_pair_handle: i32, y_pair_handle: i32, ec_handle: i32, result_handle: i32) -> Result { + println!("Called: managed_marshal_compressed_ec"); + Ok(0) + } + + fn unmarshal_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> Result { + println!("Called: unmarshal_ec"); + Ok(0) + } + + fn managed_unmarshal_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> Result { + println!("Called: managed_unmarshal_ec"); + Ok(0) + } + + fn unmarshal_compressed_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_offset: MemPtr, length: MemLength) -> Result { + println!("Called: unmarshal_compressed_ec"); + Ok(0) + } + + fn managed_unmarshal_compressed_ec(&mut self, x_result_handle: i32, y_result_handle: i32, ec_handle: i32, data_handle: i32) -> Result { + println!("Called: managed_unmarshal_compressed_ec"); + Ok(0) + } + + fn generate_key_ec(&mut self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_offset: MemPtr) -> Result { + println!("Called: generate_key_ec"); + Ok(0) + } + + fn managed_generate_key_ec(&mut self, x_pub_key_handle: i32, y_pub_key_handle: i32, ec_handle: i32, result_handle: i32) -> Result { + println!("Called: managed_generate_key_ec"); + Ok(0) + } + + fn create_ec(&mut self, data_offset: MemPtr, data_length: MemLength) -> Result { + println!("Called: create_ec"); + Ok(0) + } + + fn managed_create_ec(&mut self, data_handle: i32) -> Result { + println!("Called: managed_create_ec"); + Ok(0) + } + + fn get_curve_length_ec(&mut self, ec_handle: i32) -> Result { + println!("Called: get_curve_length_ec"); + Ok(0) + } + + fn get_priv_key_byte_length_ec(&mut self, ec_handle: i32) -> Result { + println!("Called: get_priv_key_byte_length_ec"); + Ok(0) + } + + 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 { + println!("Called: elliptic_curve_get_values"); + Ok(0) + } + + fn managed_verify_secp256r1(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result { + println!("Called: managed_verify_secp256r1"); + Ok(0) + } + + fn managed_verify_blssignature_share(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result { + println!("Called: managed_verify_blssignature_share"); + Ok(0) + } + + fn managed_verify_blsaggregated_signature(&mut self, key_handle: i32, message_handle: i32, sig_handle: i32) -> Result { + println!("Called: managed_verify_blsaggregated_signature"); + Ok(0) + } +}