multiversx-chain-vm 0.23.1

MultiversX VM implementation and tooling
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use multiversx_chain_vm_executor::VMHooksEarlyExit;
use num_bigint::{BigInt, BigUint};
use num_traits::ToPrimitive;

use crate::host::vm_hooks::VMHooksContext;
use crate::host::vm_hooks::vh_early_exit::early_exit_vm_error;
use crate::vm_err_msg;

use crate::types::RawHandle;

use super::VMHooksHandler;

/// Interface to only be used by code generated by the macros.
/// The smart contract code doesn't have access to these methods directly.
impl<C: VMHooksContext> VMHooksHandler<C> {
    pub fn get_num_arguments(&mut self) -> Result<i32, VMHooksEarlyExit> {
        self.use_gas(self.gas_schedule().base_ops_api_cost.get_num_arguments)?;

        Ok(self.context.input_ref().args.len() as i32)
    }

    pub fn get_argument_len(&mut self, arg_index: i32) -> Result<usize, VMHooksEarlyExit> {
        self.use_gas(self.gas_schedule().base_ops_api_cost.get_argument)?;

        let arg = self.context.input_ref().get_argument_vec_u8(arg_index);
        Ok(arg.len())
    }

    pub fn load_argument_managed_buffer(
        &mut self,
        arg_index: i32,
        dest: RawHandle,
    ) -> Result<(), VMHooksEarlyExit> {
        self.use_gas(
            self.gas_schedule()
                .managed_buffer_api_cost
                .m_buffer_set_bytes,
        )?;

        let arg_bytes = self.context.input_ref().get_argument_vec_u8(arg_index);
        self.context.m_types_lock().mb_set(dest, arg_bytes);

        Ok(())
    }

    pub fn load_argument_big_int_unsigned(
        &mut self,
        arg_index: i32,
        dest: RawHandle,
    ) -> Result<(), VMHooksEarlyExit> {
        self.use_gas(
            self.gas_schedule()
                .big_int_api_cost
                .big_int_set_unsigned_bytes,
        )?;

        let arg_bytes = self.context.input_ref().get_argument_vec_u8(arg_index);
        self.context
            .m_types_lock()
            .bi_set_unsigned_bytes(dest, &arg_bytes);

        Ok(())
    }

    pub fn load_argument_big_int_signed(
        &mut self,
        arg_index: i32,
        dest: RawHandle,
    ) -> Result<(), VMHooksEarlyExit> {
        self.use_gas(
            self.gas_schedule()
                .big_int_api_cost
                .big_int_set_signed_bytes,
        )?;

        let arg_bytes = self.context.input_ref().get_argument_vec_u8(arg_index);
        self.context
            .m_types_lock()
            .bi_set_signed_bytes(dest, &arg_bytes);

        Ok(())
    }

    pub fn get_argument_i64(&mut self, arg_index: i32) -> Result<i64, VMHooksEarlyExit> {
        self.use_gas(self.gas_schedule().base_ops_api_cost.int_64_get_argument)?;

        // specific implementation provided, in order to simulate the VM error (status 10 instead of 4)
        let bytes = self.context.input_ref().get_argument_vec_u8(arg_index);
        let bi = BigInt::from_signed_bytes_be(&bytes);
        if let Some(v) = bi.to_i64() {
            Ok(v)
        } else {
            Err(early_exit_vm_error(vm_err_msg::ARG_OUT_OF_RANGE))
        }
    }

    pub fn get_argument_u64(&mut self, arg_index: i32) -> Result<u64, VMHooksEarlyExit> {
        self.use_gas(self.gas_schedule().base_ops_api_cost.int_64_get_argument)?;

        // specific implementation provided, in order to simulate the VM error (status 10 instead of 4)
        let bytes = self.context.input_ref().get_argument_vec_u8(arg_index);
        let bu = BigUint::from_bytes_be(&bytes);
        if let Some(v) = bu.to_u64() {
            Ok(v)
        } else {
            Err(early_exit_vm_error(vm_err_msg::ARG_OUT_OF_RANGE))
        }
    }

    pub fn load_callback_closure_buffer(
        &mut self,
        dest: RawHandle,
    ) -> Result<(), VMHooksEarlyExit> {
        let has_closure_data = self
            .context
            .input_ref()
            .promise_callback_closure_data
            .is_some();

        if has_closure_data {
            self.use_gas(
                self.gas_schedule()
                    .managed_buffer_api_cost
                    .m_buffer_set_bytes,
            )?;

            let closure_data = self
                .context
                .input_ref()
                .promise_callback_closure_data
                .clone()
                .unwrap();

            self.context.m_types_lock().mb_set(dest, closure_data);
            Ok(())
        } else {
            Err(early_exit_vm_error(vm_err_msg::ERROR_NO_CALLBACK_CLOSURE))
        }
    }
}