Merge pull request #1936 from multiversx/rc/v0.56

Release candidate: v0.56

Author: andrei-marinica

chain/core/src/types/flags/esdt_local_role.rs

@@ -12,12 +12,10 @@ const ESDT_ROLE_NFT_ADD_QUANTITY: &str = "ESDTRoleNFTAddQuantity";
 const ESDT_ROLE_NFT_BURN: &str = "ESDTRoleNFTBurn";
 const ESDT_ROLE_NFT_ADD_URI: &str = "ESDTRoleNFTAddURI";
 const ESDT_ROLE_NFT_UPDATE_ATTRIBUTES: &str = "ESDTRoleNFTUpdateAttributes";
-const ESDT_ROLE_TRANSFER: &str = "ESDTTransferRole";
 const ESDT_ROLE_SET_NEW_URI: &str = "ESDTRoleSetNewURI";
 const ESDT_ROLE_MODIFY_ROYALTIES: &str = "ESDTRoleModifyRoyalties";
 const ESDT_ROLE_MODIFY_CREATOR: &str = "ESDTRoleModifyCreator";
 const ESDT_ROLE_NFT_RECREATE: &str = "ESDTRoleNFTRecreate";
-const ESDT_ROLE_NFT_UPDATE: &str = "ESDTRoleNFTUpdate";
 
 #[derive(TopDecode, TopEncode, NestedDecode, NestedEncode, Clone, PartialEq, Eq, Debug, Copy)]
 pub enum EsdtLocalRole {
@@ -27,14 +25,12 @@ pub enum EsdtLocalRole {
     NftCreate,
     NftAddQuantity,
     NftBurn,
-    NftAddUri,
     NftUpdateAttributes,
-    Transfer,
-    SetNewUri,
+    NftAddUri,
+    NftRecreate,
     ModifyRoyalties,
     ModifyCreator,
-    NftRecreate,
-    NftUpdate,
+    SetNewUri,
 }
 
 impl EsdtLocalRole {
@@ -46,14 +42,12 @@ impl EsdtLocalRole {
             Self::NftCreate => 3,
             Self::NftAddQuantity => 4,
             Self::NftBurn => 5,
-            Self::NftAddUri => 6,
-            Self::NftUpdateAttributes => 7,
-            Self::Transfer => 8,
-            Self::SetNewUri => 9,
+            Self::NftUpdateAttributes => 6,
+            Self::NftAddUri => 7,
+            Self::NftRecreate => 8,
+            Self::ModifyCreator => 9,
             Self::ModifyRoyalties => 10,
-            Self::ModifyCreator => 11,
-            Self::NftRecreate => 12,
-            Self::NftUpdate => 13,
+            Self::SetNewUri => 11,
         }
     }
 
@@ -69,14 +63,12 @@ impl EsdtLocalRole {
             Self::NftCreate => ESDT_ROLE_NFT_CREATE,
             Self::NftAddQuantity => ESDT_ROLE_NFT_ADD_QUANTITY,
             Self::NftBurn => ESDT_ROLE_NFT_BURN,
-            Self::NftAddUri => ESDT_ROLE_NFT_ADD_URI,
             Self::NftUpdateAttributes => ESDT_ROLE_NFT_UPDATE_ATTRIBUTES,
-            Self::Transfer => ESDT_ROLE_TRANSFER,
-            Self::SetNewUri => ESDT_ROLE_SET_NEW_URI,
+            Self::NftAddUri => ESDT_ROLE_NFT_ADD_URI,
+            Self::NftRecreate => ESDT_ROLE_NFT_RECREATE,
             Self::ModifyRoyalties => ESDT_ROLE_MODIFY_ROYALTIES,
             Self::ModifyCreator => ESDT_ROLE_MODIFY_CREATOR,
-            Self::NftRecreate => ESDT_ROLE_NFT_RECREATE,
-            Self::NftUpdate => ESDT_ROLE_NFT_UPDATE,
+            Self::SetNewUri => ESDT_ROLE_SET_NEW_URI,
         }
     }
 
@@ -88,34 +80,30 @@ impl EsdtLocalRole {
             Self::NftCreate => EsdtLocalRoleFlags::NFT_CREATE,
             Self::NftAddQuantity => EsdtLocalRoleFlags::NFT_ADD_QUANTITY,
             Self::NftBurn => EsdtLocalRoleFlags::NFT_BURN,
-            Self::NftAddUri => EsdtLocalRoleFlags::NFT_ADD_URI,
             Self::NftUpdateAttributes => EsdtLocalRoleFlags::NFT_UPDATE_ATTRIBUTES,
-            Self::Transfer => EsdtLocalRoleFlags::TRANSFER,
-            Self::SetNewUri => EsdtLocalRoleFlags::SET_NEW_URI,
+            Self::NftAddUri => EsdtLocalRoleFlags::NFT_ADD_URI,
+            Self::NftRecreate => EsdtLocalRoleFlags::NFT_RECREATE,
             Self::ModifyRoyalties => EsdtLocalRoleFlags::MODIFY_ROYALTIES,
             Self::ModifyCreator => EsdtLocalRoleFlags::MODIFY_CREATOR,
-            Self::NftRecreate => EsdtLocalRoleFlags::NFT_RECREATE,
-            Self::NftUpdate => EsdtLocalRoleFlags::NFT_UPDATE,
+            Self::SetNewUri => EsdtLocalRoleFlags::SET_NEW_URI,
         }
     }
 }
 
 // TODO: can be done with macros, but I didn't find a public library that does it and is no_std
 // we can implement it, it's easy
-const ALL_ROLES: [EsdtLocalRole; 13] = [
+const ALL_ROLES: [EsdtLocalRole; 11] = [
     EsdtLocalRole::Mint,
     EsdtLocalRole::Burn,
     EsdtLocalRole::NftCreate,
     EsdtLocalRole::NftAddQuantity,
     EsdtLocalRole::NftBurn,
-    EsdtLocalRole::NftAddUri,
     EsdtLocalRole::NftUpdateAttributes,
-    EsdtLocalRole::Transfer,
-    EsdtLocalRole::SetNewUri,
+    EsdtLocalRole::NftAddUri,
+    EsdtLocalRole::NftRecreate,
     EsdtLocalRole::ModifyRoyalties,
     EsdtLocalRole::ModifyCreator,
-    EsdtLocalRole::NftRecreate,
-    EsdtLocalRole::NftUpdate,
+    EsdtLocalRole::SetNewUri,
 ];
 
 impl EsdtLocalRole {
@@ -133,14 +121,12 @@ impl From<u16> for EsdtLocalRole {
             3 => Self::NftCreate,
             4 => Self::NftAddQuantity,
             5 => Self::NftBurn,
-            6 => Self::NftAddUri,
-            7 => Self::NftUpdateAttributes,
-            8 => Self::Transfer,
-            9 => Self::SetNewUri,
-            10 => Self::ModifyRoyalties,
-            11 => Self::ModifyCreator,
-            12 => Self::NftRecreate,
-            13 => Self::NftUpdate,
+            6 => Self::NftUpdateAttributes,
+            7 => Self::NftAddUri,
+            8 => Self::NftRecreate,
+            9 => Self::ModifyRoyalties,
+            10 => Self::ModifyCreator,
+            11 => Self::SetNewUri,
             _ => Self::None,
         }
     }
@@ -159,22 +145,18 @@ impl<'a> From<&'a [u8]> for EsdtLocalRole {
             Self::NftAddQuantity
         } else if byte_slice == ESDT_ROLE_NFT_BURN.as_bytes() {
             Self::NftBurn
-        } else if byte_slice == ESDT_ROLE_NFT_ADD_URI.as_bytes() {
-            Self::NftAddUri
         } else if byte_slice == ESDT_ROLE_NFT_UPDATE_ATTRIBUTES.as_bytes() {
             Self::NftUpdateAttributes
-        } else if byte_slice == ESDT_ROLE_TRANSFER.as_bytes() {
-            Self::Transfer
-        } else if byte_slice == ESDT_ROLE_SET_NEW_URI.as_bytes() {
-            Self::SetNewUri
+        } else if byte_slice == ESDT_ROLE_NFT_ADD_URI.as_bytes() {
+            Self::NftAddUri
+        } else if byte_slice == ESDT_ROLE_NFT_RECREATE.as_bytes() {
+            Self::NftRecreate
         } else if byte_slice == ESDT_ROLE_MODIFY_ROYALTIES.as_bytes() {
             Self::ModifyRoyalties
         } else if byte_slice == ESDT_ROLE_MODIFY_CREATOR.as_bytes() {
             Self::ModifyCreator
-        } else if byte_slice == ESDT_ROLE_NFT_RECREATE.as_bytes() {
-            Self::NftRecreate
-        } else if byte_slice == ESDT_ROLE_NFT_UPDATE.as_bytes() {
-            Self::NftUpdate
+        } else if byte_slice == ESDT_ROLE_SET_NEW_URI.as_bytes() {
+            Self::SetNewUri
         } else {
             Self::None
         }

chain/core/src/types/flags/esdt_local_role_flags.rs

@@ -1,25 +1,21 @@
-#![allow(clippy::bad_bit_mask)]
-
 use super::EsdtLocalRole;
 use bitflags::bitflags;
 
 bitflags! {
     #[derive(PartialEq, Clone, Copy)]
     pub struct EsdtLocalRoleFlags: u64 {
-        const NONE                  = 0b00000000;
-        const MINT                  = 0b00000001;
-        const BURN                  = 0b00000010;
-        const NFT_CREATE            = 0b00000100;
-        const NFT_ADD_QUANTITY      = 0b00001000;
-        const NFT_BURN              = 0b00010000;
-        const NFT_ADD_URI           = 0b00100000;
-        const NFT_UPDATE_ATTRIBUTES = 0b01000000;
-        const TRANSFER              = 0b10000000;
-        const SET_NEW_URI           = 0b00000001_00000000;
+        const NONE                  = 0b00000000_00000000;
+        const MINT                  = 0b00000000_00000001;
+        const BURN                  = 0b00000000_00000010;
+        const NFT_CREATE            = 0b00000000_00000100;
+        const NFT_ADD_QUANTITY      = 0b00000000_00001000;
+        const NFT_BURN              = 0b00000000_00010000;
+        const NFT_UPDATE_ATTRIBUTES = 0b00000000_00100000;
+        const NFT_ADD_URI           = 0b00000000_01000000;
+        const NFT_RECREATE          = 0b00000000_10000000;
+        const MODIFY_CREATOR        = 0b00000001_00000000;
         const MODIFY_ROYALTIES      = 0b00000010_00000000;
-        const MODIFY_CREATOR        = 0b00000100_00000000;
-        const NFT_RECREATE          = 0b00001000_00000000;
-        const NFT_UPDATE            = 0b00010000_00000000;
+        const SET_NEW_URI           = 0b00000100_00000000;
     }
 }
 

chain/vm/src/tx_mock/tx_input.rs

@@ -18,6 +18,7 @@ pub struct TxInput {
     pub func_name: TxFunctionName,
     pub args: Vec<Vec<u8>>,
     pub call_type: CallType,
+    pub readonly: bool, // should probably be in TxContext, but it is easier to keep it here, for now
     pub gas_limit: u64,
     pub gas_price: u64,
     pub tx_hash: H256,
@@ -35,6 +36,7 @@ impl Default for TxInput {
             func_name: TxFunctionName::EMPTY,
             args: Vec::new(),
             call_type: CallType::DirectCall,
+            readonly: false,
             gas_limit: 0,
             gas_price: 0,
             tx_hash: H256::zero(),

chain/vm/src/vm_err_msg.rs

@@ -9,6 +9,8 @@ pub const EXPONENT_IS_POSITIVE: &str = "exponent must be negative";
 pub const NUMBER_IS_NOT_NORMAL: &str =
     "number is not normal. It is either infinite, NaN or subnormal";
 pub const CANNOT_COMPARE_VALUES: &str = "values are not comparable";
+pub const WRITE_RESERVED: &str = "cannot write to storage under reserved key";
+pub const WRITE_READONLY: &str = "cannot write on read only mode";
 
 pub const ERROR_SIGNALLED_BY_SMARTCONTRACT: &str = "error signalled by smartcontract";
 

chain/vm/src/vm_hooks/vh_dispatcher.rs

@@ -848,7 +848,14 @@ impl VMHooks for VMHooksDispatcher {
         arguments_handle: i32,
         result_handle: i32,
     ) -> i32 {
-        panic!("Unavailable: managed_execute_read_only")
+        self.handler.execute_on_dest_context_readonly_raw(
+            gas as u64,
+            address_handle,
+            function_handle,
+            arguments_handle,
+            result_handle,
+        );
+        0
     }
 
     fn managed_execute_on_same_context(

chain/vm/src/vm_hooks/vh_handler/vh_send.rs

@@ -375,6 +375,26 @@ pub trait VMHooksSend: VMHooksHandlerSource {
             .mb_set_vec_of_bytes(result_handle, result);
     }
 
+    fn execute_on_dest_context_readonly_raw(
+        &self,
+        _gas: u64,
+        to_handle: RawHandle,
+        endpoint_name_handle: RawHandle,
+        arg_buffer_handle: RawHandle,
+        result_handle: RawHandle,
+    ) {
+        let to = self.m_types_lock().mb_to_address(to_handle);
+        let endpoint_name = self
+            .m_types_lock()
+            .mb_to_function_name(endpoint_name_handle);
+        let arg_buffer = self.m_types_lock().mb_get_vec_of_bytes(arg_buffer_handle);
+
+        let result = self.perform_execute_on_dest_context_readonly(to, endpoint_name, arg_buffer);
+
+        self.m_types_lock()
+            .mb_set_vec_of_bytes(result_handle, result);
+    }
+
     fn clean_return_data(&self) {
         let mut tx_result = self.result_lock();
         tx_result.result_values.clear();

chain/vm/src/vm_hooks/vh_impl/vh_debug_api.rs

@@ -2,6 +2,8 @@ use std::sync::{Arc, MutexGuard};
 
 use multiversx_chain_core::types::ReturnCode;
 use multiversx_chain_vm_executor::BreakpointValue;
+use num_bigint::BigUint;
+use num_traits::Zero;
 
 use crate::{
     tx_execution::execute_current_tx_context_input,
@@ -66,6 +68,7 @@ impl VMHooksHandlerSource for DebugApiVMHooksHandler {
 
     fn storage_write(&self, key: &[u8], value: &[u8]) {
         self.check_reserved_key(key);
+        self.check_not_readonly();
 
         self.0.with_contract_account_mut(|account| {
             account.storage.insert(key.to_vec(), value.to_vec());
@@ -136,6 +139,31 @@ impl VMHooksHandlerSource for DebugApiVMHooksHandler {
         }
     }
 
+    fn perform_execute_on_dest_context_readonly(
+        &self,
+        to: VMAddress,
+        func_name: TxFunctionName,
+        arguments: Vec<Vec<u8>>,
+    ) -> Vec<Vec<u8>> {
+        let async_call_data =
+            self.create_async_call_data(to, BigUint::zero(), func_name, arguments);
+        let mut tx_input = async_call_tx_input(&async_call_data, CallType::ExecuteOnDestContext);
+        tx_input.readonly = true;
+        let tx_cache = TxCache::new(self.0.blockchain_cache_arc());
+        let (tx_result, blockchain_updates) = self.0.vm_ref.execute_builtin_function_or_default(
+            tx_input,
+            tx_cache,
+            execute_current_tx_context_input,
+        );
+
+        if tx_result.result_status.is_success() {
+            self.sync_call_post_processing(tx_result, blockchain_updates)
+        } else {
+            // also kill current execution
+            self.halt_with_error(tx_result.result_status, &tx_result.result_message)
+        }
+    }
+
     fn perform_deploy(
         &self,
         egld_value: num_bigint::BigUint,
@@ -249,7 +277,14 @@ impl DebugApiVMHooksHandler {
 
     fn check_reserved_key(&self, key: &[u8]) {
         if key.starts_with(STORAGE_RESERVED_PREFIX) {
-            self.vm_error("cannot write to storage under reserved key");
+            self.vm_error(vm_err_msg::WRITE_RESERVED);
+        }
+    }
+
+    /// TODO: only checked on storage writes, needs more checks for calls, transfers, etc.
+    fn check_not_readonly(&self) {
+        if self.0.input_ref().readonly {
+            self.vm_error(vm_err_msg::WRITE_READONLY);
         }
     }
 

chain/vm/src/vm_hooks/vh_impl/vh_single_tx_api.rs

@@ -127,6 +127,15 @@ impl VMHooksHandlerSource for SingleTxApiVMHooksHandler {
         panic!("cannot launch contract calls in the SingleTxApi")
     }
 
+    fn perform_execute_on_dest_context_readonly(
+        &self,
+        _to: VMAddress,
+        _func_name: TxFunctionName,
+        _arguments: Vec<Vec<u8>>,
+    ) -> Vec<Vec<u8>> {
+        panic!("cannot launch contract calls in the SingleTxApi")
+    }
+
     fn perform_deploy(
         &self,
         _egld_value: num_bigint::BigUint,

chain/vm/src/vm_hooks/vh_impl/vh_static_api.rs

@@ -102,6 +102,15 @@ impl VMHooksHandlerSource for StaticApiVMHooksHandler {
         panic!("cannot launch contract calls in the StaticApi")
     }
 
+    fn perform_execute_on_dest_context_readonly(
+        &self,
+        _to: VMAddress,
+        _func_name: TxFunctionName,
+        _arguments: Vec<Vec<u8>>,
+    ) -> Vec<Vec<u8>> {
+        panic!("cannot launch contract calls in the StaticApi")
+    }
+
     fn perform_deploy(
         &self,
         _egld_value: num_bigint::BigUint,

chain/vm/src/vm_hooks/vh_source.rs

@@ -82,6 +82,13 @@ pub trait VMHooksHandlerSource: Debug {
         args: Vec<Vec<u8>>,
     ) -> Vec<Vec<u8>>;
 
+    fn perform_execute_on_dest_context_readonly(
+        &self,
+        to: VMAddress,
+        func_name: TxFunctionName,
+        arguments: Vec<Vec<u8>>,
+    ) -> Vec<Vec<u8>>;
+
     fn perform_deploy(
         &self,
         egld_value: num_bigint::BigUint,