Merge pull request #1921 from multiversx/feat/barnard

feat/barnard (targeting VM barnard release)

Author: andrei-marinica

Cargo.lock

@@ -114,6 +114,9 @@ members = [
   "contracts/feature-tests/abi-tester/meta",
   "contracts/feature-tests/alloc-features",
   "contracts/feature-tests/alloc-features/meta",
+  "contracts/feature-tests/barnard-features",
+  "contracts/feature-tests/barnard-features/meta",
+  "contracts/feature-tests/barnard-features/interactor",
   "contracts/feature-tests/basic-features",
   "contracts/feature-tests/basic-features/meta",
   "contracts/feature-tests/basic-features/interact",
@@ -133,8 +136,10 @@ members = [
   "contracts/feature-tests/composability/execute-on-dest-esdt-issue-callback/child",
   "contracts/feature-tests/composability/execute-on-dest-esdt-issue-callback/child/meta",
   "contracts/feature-tests/composability/forwarder",
-  "contracts/feature-tests/composability/forwarder-interactor",
   "contracts/feature-tests/composability/forwarder/meta",
+  "contracts/feature-tests/composability/forwarder-barnard",
+  "contracts/feature-tests/composability/forwarder-barnard/meta",
+  "contracts/feature-tests/composability/forwarder-interactor",
   "contracts/feature-tests/composability/forwarder-legacy",
   "contracts/feature-tests/composability/forwarder-legacy/meta",
   "contracts/feature-tests/composability/forwarder-queue",

Cargo.toml

@@ -1,5 +1,3 @@
-// use multiversx_sc_derive::{type_abi, ManagedVecItem};
-
 use crate::codec::{
     self,
     derive::{NestedDecode, NestedEncode, TopDecode, TopEncode},
@@ -102,3 +100,19 @@ impl<'a> From<&'a [u8]> for EsdtTokenType {
         }
     }
 }
+
+impl From<Option<u64>> for EsdtTokenType {
+    #[inline]
+    fn from(value: Option<u64>) -> Self {
+        match value {
+            Some(0) => Self::Fungible,
+            Some(1) => Self::NonFungible,
+            Some(2) => Self::SemiFungible,
+            Some(3) => Self::Meta,
+            Some(4) => Self::DynamicNFT,
+            Some(5) => Self::DynamicSFT,
+            Some(6) => Self::DynamicMeta,
+            _ => Self::Invalid,
+        }
+    }
+}

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

@@ -45,7 +45,11 @@ path = "../core"
 
 [dependencies.multiversx-chain-vm-executor]
 version = "0.4.0"
+git = "https://github.com/multiversx/mx-vm-executor-rs"
+rev = "5804799ee7b6446c9e7641b8308acb48ec00d751"
 
 [dependencies.multiversx-chain-vm-executor-wasmer-experimental]
 version = "0.4.0"
 optional = true
+git = "https://github.com/multiversx/mx-vm-executor-rs"
+rev = "5804799ee7b6446c9e7641b8308acb48ec00d751"

chain/vm/Cargo.toml

@@ -6,7 +6,9 @@ mod tx_managed_map;
 
 pub use handle_map::HandleMap;
 use num_bigint::BigInt;
-pub use tx_big_int::big_int_to_i64;
+pub use tx_big_int::{
+    big_int_signed_bytes, big_int_to_i64, big_uint_to_u64, big_uint_unsigned_bytes,
+};
 pub use tx_managed_buffer::InvalidSliceError;
 
 use std::collections::HashMap;

chain/vm/src/host/context/managed_type_container.rs

@@ -47,11 +47,7 @@ impl ManagedTypeContainer {
 
     pub fn bi_get_signed_bytes(&self, handle: RawHandle) -> Vec<u8> {
         let bi = self.bi_get(handle);
-        if bi.is_zero() {
-            Vec::new()
-        } else {
-            bi.to_signed_bytes_be()
-        }
+        big_int_signed_bytes(&bi)
     }
 
     pub fn bi_set_signed_bytes(&mut self, destination: RawHandle, bytes: &[u8]) {
@@ -90,3 +86,28 @@ pub fn big_int_to_i64(bi: &num_bigint::BigInt) -> Option<i64> {
         },
     }
 }
+
+pub fn big_uint_to_u64(bu: &num_bigint::BigUint) -> Option<u64> {
+    let digits = bu.to_u64_digits();
+    match digits.len() {
+        0 => Some(0),
+        1 => Some(digits[0]),
+        _ => None,
+    }
+}
+
+pub fn big_uint_unsigned_bytes(bu: &num_bigint::BigUint) -> Vec<u8> {
+    if bu.is_zero() {
+        Vec::new()
+    } else {
+        bu.to_bytes_be()
+    }
+}
+
+pub fn big_int_signed_bytes(bi: &num_bigint::BigInt) -> Vec<u8> {
+    if bi.is_zero() {
+        Vec::new()
+    } else {
+        bi.to_signed_bytes_be()
+    }
+}

chain/vm/src/host/context/managed_type_container/tx_big_int.rs

@@ -501,6 +501,10 @@ impl<C: VMHooksContext> VMHooks for VMHooksDispatcher<C> {
         self.handler.get_block_timestamp()
     }
 
+    fn get_block_timestamp_ms(&mut self) -> Result<i64, VMHooksEarlyExit> {
+        self.handler.get_block_timestamp_ms()
+    }
+
     fn get_block_nonce(&mut self) -> Result<i64, VMHooksEarlyExit> {
         self.handler.get_block_nonce()
     }
@@ -525,6 +529,10 @@ impl<C: VMHooksContext> VMHooks for VMHooksDispatcher<C> {
         self.handler.get_prev_block_timestamp()
     }
 
+    fn get_prev_block_timestamp_ms(&mut self) -> Result<i64, VMHooksEarlyExit> {
+        self.handler.get_prev_block_timestamp_ms()
+    }
+
     fn get_prev_block_nonce(&mut self) -> Result<i64, VMHooksEarlyExit> {
         self.handler.get_prev_block_nonce()
     }
@@ -700,6 +708,22 @@ impl<C: VMHooksContext> VMHooks for VMHooksDispatcher<C> {
         self.handler.get_prev_block_random_seed(result_handle)
     }
 
+    fn get_block_round_time_ms(&mut self) -> Result<i64, VMHooksEarlyExit> {
+        panic!("Unavailable: get_block_round_time_ms")
+    }
+
+    fn epoch_start_block_timestamp_ms(&mut self) -> Result<i64, VMHooksEarlyExit> {
+        panic!("Unavailable: epoch_start_block_timestamp")
+    }
+
+    fn epoch_start_block_nonce(&mut self) -> Result<i64, VMHooksEarlyExit> {
+        panic!("Unavailable: epoch_start_block_nonce")
+    }
+
+    fn epoch_start_block_round(&mut self) -> Result<i64, VMHooksEarlyExit> {
+        panic!("Unavailable: epoch_start_block_round")
+    }
+
     fn managed_get_return_data(
         &mut self,
         result_id: i32,
@@ -708,6 +732,13 @@ impl<C: VMHooksContext> VMHooks for VMHooksDispatcher<C> {
         panic!("Unavailable: managed_get_return_data");
     }
 
+    fn managed_get_all_transfers_call_value(
+        &mut self,
+        all_transfers_handle: i32,
+    ) -> Result<(), VMHooksEarlyExit> {
+        self.handler.load_all_transfers(all_transfers_handle)
+    }
+
     fn managed_get_multi_esdt_call_value(
         &mut self,
         multi_call_value_handle: i32,
@@ -755,6 +786,16 @@ impl<C: VMHooksContext> VMHooks for VMHooksDispatcher<C> {
         )
     }
 
+    fn managed_get_esdt_token_type(
+        &mut self,
+        address_handle: i32,
+        token_id_handle: i32,
+        nonce: i64,
+        type_handle: i32,
+    ) -> Result<(), VMHooksEarlyExit> {
+        panic!("Unavailable: managed_get_esdt_token_type")
+    }
+
     fn managed_get_back_transfers(
         &mut self,
         esdt_transfer_value_handle: i32,
@@ -961,6 +1002,18 @@ impl<C: VMHooksContext> VMHooks for VMHooksDispatcher<C> {
         Ok(RESULT_OK)
     }
 
+    fn managed_execute_on_dest_context_with_error_return(
+        &mut self,
+        gas: i64,
+        address_handle: i32,
+        value_handle: i32,
+        function_handle: i32,
+        arguments_handle: i32,
+        result_handle: i32,
+    ) -> Result<i32, VMHooksEarlyExit> {
+        panic!("Unavailable: managed_execute_on_dest_context_with_error_return")
+    }
+
     fn managed_multi_transfer_esdt_nft_execute(
         &mut self,
         dst_handle: i32,
@@ -979,6 +1032,24 @@ impl<C: VMHooksContext> VMHooks for VMHooksDispatcher<C> {
         Ok(RESULT_OK)
     }
 
+    fn managed_multi_transfer_esdt_nft_execute_with_return(
+        &mut self,
+        dst_handle: i32,
+        token_transfers_handle: i32,
+        gas_limit: i64,
+        function_handle: i32,
+        arguments_handle: i32,
+    ) -> Result<i32, VMHooksEarlyExit> {
+        self.handler
+            .managed_multi_transfer_esdt_nft_execute_with_return(
+                dst_handle,
+                token_transfers_handle,
+                gas_limit as u64,
+                function_handle,
+                arguments_handle,
+            )
+    }
+
     fn managed_transfer_value_execute(
         &mut self,
         dst_handle: i32,
@@ -1038,6 +1109,14 @@ impl<C: VMHooksContext> VMHooks for VMHooksDispatcher<C> {
             .managed_get_code_metadata(address_handle, response_handle)
     }
 
+    fn managed_get_code_hash(
+        &mut self,
+        address_handle: i32,
+        code_hash_handle: i32,
+    ) -> Result<(), VMHooksEarlyExit> {
+        panic!("Unavailable: managed_get_code_hash")
+    }
+
     fn managed_is_builtin_function(
         &mut self,
         function_name_handle: i32,
@@ -1745,6 +1824,38 @@ impl<C: VMHooksContext> VMHooks for VMHooksDispatcher<C> {
         }
     }
 
+    fn mbuffer_to_small_int_unsigned(
+        &mut self,
+        m_buffer_handle: i32,
+    ) -> Result<i64, VMHooksEarlyExit> {
+        self.handler.mb_to_small_int_unsigned(m_buffer_handle)
+    }
+
+    fn mbuffer_to_small_int_signed(
+        &mut self,
+        m_buffer_handle: i32,
+    ) -> Result<i64, VMHooksEarlyExit> {
+        self.handler.mb_to_small_int_signed(m_buffer_handle)
+    }
+
+    fn mbuffer_from_small_int_unsigned(
+        &mut self,
+        m_buffer_handle: i32,
+        value: i64,
+    ) -> Result<(), VMHooksEarlyExit> {
+        self.handler
+            .mb_from_small_int_unsigned(m_buffer_handle, value as u64)
+    }
+
+    fn mbuffer_from_small_int_signed(
+        &mut self,
+        m_buffer_handle: i32,
+        value: i64,
+    ) -> Result<(), VMHooksEarlyExit> {
+        self.handler
+            .mb_from_small_int_signed(m_buffer_handle, value)
+    }
+
     fn mbuffer_to_big_float(
         &mut self,
         m_buffer_handle: i32,

chain/vm/src/host/vm_hooks/vh_dispatcher.rs

@@ -137,6 +137,10 @@ impl<C: VMHooksContext> VMHooksHandler<C> {
         Ok(self.context.get_current_block_info().block_timestamp as i64)
     }
 
+    pub fn get_block_timestamp_ms(&mut self) -> Result<i64, VMHooksEarlyExit> {
+        self.get_block_timestamp().map(|t| t * 1000)
+    }
+
     pub fn get_block_nonce(&mut self) -> Result<i64, VMHooksEarlyExit> {
         self.use_gas(self.gas_schedule().base_ops_api_cost.get_block_nonce)?;
 
@@ -174,6 +178,10 @@ impl<C: VMHooksContext> VMHooksHandler<C> {
         Ok(self.context.get_previous_block_info().block_timestamp as i64)
     }
 
+    pub fn get_prev_block_timestamp_ms(&mut self) -> Result<i64, VMHooksEarlyExit> {
+        self.get_prev_block_timestamp().map(|t| t * 1000)
+    }
+
     pub fn get_prev_block_nonce(&mut self) -> Result<i64, VMHooksEarlyExit> {
         self.use_gas(self.gas_schedule().base_ops_api_cost.get_block_nonce)?;
 

chain/vm/src/host/vm_hooks/vh_handler/vh_blockchain.rs

@@ -1,8 +1,12 @@
 use crate::{
-    host::vm_hooks::{vh_early_exit::early_exit_vm_error, VMHooksContext},
+    host::{
+        context::TxTokenTransfer,
+        vm_hooks::{vh_early_exit::early_exit_vm_error, VMHooksContext},
+    },
     types::RawHandle,
     vm_err_msg,
 };
+use multiversx_chain_core::EGLD_000000_TOKEN_IDENTIFIER;
 use multiversx_chain_vm_executor::VMHooksEarlyExit;
 use num_traits::Zero;
 
@@ -43,6 +47,23 @@ impl<C: VMHooksContext> VMHooksHandler<C> {
         Ok(())
     }
 
+    pub fn load_all_transfers(&self, dest_handle: RawHandle) -> Result<(), VMHooksEarlyExit> {
+        let direct_egld_value = self.context.input_ref().received_egld().clone();
+        let transfers = if !direct_egld_value.is_zero() {
+            vec![TxTokenTransfer {
+                token_identifier: EGLD_000000_TOKEN_IDENTIFIER.as_bytes().to_vec(),
+                nonce: 0,
+                value: direct_egld_value,
+            }]
+        } else {
+            self.context.input_ref().received_esdt().to_owned()
+        };
+        self.context
+            .m_types_lock()
+            .mb_set_vec_of_esdt_payments(dest_handle, &transfers);
+        Ok(())
+    }
+
     pub fn esdt_num_transfers(&mut self) -> usize {
         self.context.input_ref().received_esdt().len()
     }