Managed dealloc: managed buffers

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

@@ -49,6 +49,10 @@ impl<V> HandleMap<V> {
     }
 
     pub fn remove_handle(&mut self, handle: RawHandle) {
+        assert!(
+            self.map.contains_key(&handle),
+            "attempting to remove non-existing handle {handle}, this is a memory managedment issue"
+        );
         let _ = self.map.remove(&handle);
     }
 }

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

@@ -185,6 +185,7 @@ impl ManagedTypeContainer {
     }
 
     pub fn mb_remove(&mut self, handle: RawHandle) {
+        println!("removing MB: {handle}");
         self.managed_buffer_map.remove_handle(handle);
     }
 }

contracts/feature-tests/composability/forwarder-barnard/src/forwarder_barnard.rs

@@ -23,7 +23,7 @@ pub trait ForwarderBarnard {
             .to(&to)
             .gas(half_gas)
             .raw_call(endpoint_name)
-            .arguments_raw(args.to_arg_buffer())
+            .arguments_raw(args.into_arg_buffer())
             .returns(ReturnsHandledOrError::new().returns(ReturnsRawResult))
             .sync_call_fallible();
 

contracts/feature-tests/composability/forwarder-legacy/src/fwd_nft_legacy.rs

@@ -238,7 +238,7 @@ pub trait ForwarderNftModule: fwd_storage_legacy::ForwarderStorageModule {
             &amount,
             self.blockchain().get_gas_left(),
             &function,
-            &arguments.to_arg_buffer(),
+            &arguments.into_arg_buffer(),
         );
     }
 

contracts/feature-tests/composability/forwarder-queue/src/forwarder_queue.rs

@@ -96,7 +96,7 @@ pub trait ForwarderQueue {
             to,
             gas_limit,
             endpoint_name,
-            args: args.to_arg_buffer(),
+            args: args.into_arg_buffer(),
             payments,
         });
     }
@@ -144,7 +144,7 @@ pub trait ForwarderQueue {
             to,
             gas_limit,
             endpoint_name,
-            args: args.to_arg_buffer(),
+            args: args.into_arg_buffer(),
             payments,
         });
     }

contracts/feature-tests/composability/forwarder-raw/src/forwarder_raw_alt_init.rs

@@ -20,7 +20,7 @@ pub trait ForwarderRawAlternativeInit: super::forwarder_raw_common::ForwarderRaw
         self.tx()
             .to(&to)
             .raw_call(endpoint_name)
-            .arguments_raw(args.to_arg_buffer())
+            .arguments_raw(args.into_arg_buffer())
             .async_call_and_exit();
     }
 
@@ -61,7 +61,7 @@ pub trait ForwarderRawAlternativeInit: super::forwarder_raw_common::ForwarderRaw
             .gas(half_gas)
             .egld(payment)
             .raw_call(endpoint_name)
-            .arguments_raw(args.to_arg_buffer())
+            .arguments_raw(args.into_arg_buffer())
             .returns(ReturnsRawResult)
             .sync_call();
 

contracts/feature-tests/composability/forwarder-raw/src/forwarder_raw_async.rs

@@ -48,7 +48,7 @@ pub trait ForwarderRawAsync: super::forwarder_raw_common::ForwarderRawCommon {
         self.tx()
             .to(to)
             .raw_call(endpoint_name)
-            .arguments_raw(args.to_arg_buffer())
+            .arguments_raw(args.into_arg_buffer())
             .payment(EgldOrEsdtTokenPayment::new(
                 payment_token,
                 0,

contracts/feature-tests/composability/forwarder-raw/src/forwarder_raw_deploy_upgrade.rs

@@ -13,7 +13,7 @@ pub trait ForwarderRawDeployUpgrade {
             .raw_deploy()
             .code(code)
             .code_metadata(code_metadata)
-            .arguments_raw(args.to_arg_buffer())
+            .arguments_raw(args.into_arg_buffer())
             .gas(self.blockchain().get_gas_left())
             .returns(ReturnsNewManagedAddress)
             .returns(ReturnsRawResult)
@@ -32,7 +32,7 @@ pub trait ForwarderRawDeployUpgrade {
             .raw_deploy()
             .from_source(source_contract_address)
             .code_metadata(code_metadata)
-            .arguments_raw(args.to_arg_buffer())
+            .arguments_raw(args.into_arg_buffer())
             .gas(self.blockchain().get_gas_left())
             .returns(ReturnsNewManagedAddress)
             .sync_call()
@@ -51,7 +51,7 @@ pub trait ForwarderRawDeployUpgrade {
             .raw_upgrade()
             .code(new_code)
             .code_metadata(code_metadata)
-            .arguments_raw(args.to_arg_buffer())
+            .arguments_raw(args.into_arg_buffer())
             .upgrade_async_call_and_exit();
     }
 
@@ -68,7 +68,7 @@ pub trait ForwarderRawDeployUpgrade {
             .raw_upgrade()
             .from_source(source_contract_address)
             .code_metadata(code_metadata)
-            .arguments_raw(args.to_arg_buffer())
+            .arguments_raw(args.into_arg_buffer())
             .gas(self.blockchain().get_gas_left())
             .upgrade_async_call_and_exit();
     }

contracts/feature-tests/composability/forwarder-raw/src/forwarder_raw_sync.rs

@@ -36,7 +36,7 @@ pub trait ForwarderRawSync: super::forwarder_raw_common::ForwarderRawCommon {
         let payment = self.call_value().egld();
         let one_third_gas = self.blockchain().get_gas_left() / 3;
         let half_payment = &*payment / 2u32;
-        let arg_buffer = args.to_arg_buffer();
+        let arg_buffer = args.into_arg_buffer();
 
         let result = self
             .tx()

contracts/feature-tests/composability/forwarder/src/fwd_call_promise_direct.rs

@@ -35,7 +35,7 @@ pub trait CallPromisesDirectModule {
             .to(&to)
             .raw_call(endpoint_name)
             .payment(payment)
-            .arguments_raw(args.to_arg_buffer())
+            .arguments_raw(args.into_arg_buffer())
             .gas(gas_limit)
             .callback(self.callbacks().the_one_callback(1001, 1002u32.into()))
             .gas_for_callback(extra_gas_for_callback)

contracts/feature-tests/composability/forwarder/src/fwd_nft.rs

@@ -244,7 +244,7 @@ pub trait ForwarderNftModule: fwd_storage::ForwarderStorageModule {
             .to(&to)
             .gas(gas_left)
             .raw_call(function)
-            .arguments_raw(arguments.to_arg_buffer())
+            .arguments_raw(arguments.into_arg_buffer())
             .single_esdt(&token_identifier, nonce, &amount)
             .transfer_execute();
     }

framework/base/src/api/managed_types/managed_type_api_impl.rs

@@ -60,6 +60,9 @@ pub trait ManagedTypeApiImpl:
         token_identifier_util::get_token_ticker_len(token_id_len)
     }
 
+    fn requires_managed_type_drop(&self) -> bool {
+        false
+    }
     fn drop_managed_buffer(&self, _handle: Self::ManagedBufferHandle) {}
     fn drop_big_float(&self, _handle: Self::BigFloatHandle) {}
     fn drop_big_int(&self, _handle: Self::BigIntHandle) {}

framework/base/src/contract_base/wrappers/blockchain_wrapper.rs

@@ -12,8 +12,8 @@ use crate::{
     types::{
         BackTransfers, BackTransfersLegacy, BigUint, CodeMetadata, EgldOrEsdtTokenIdentifier,
         EgldOrEsdtTokenPayment, EsdtLocalRoleFlags, EsdtTokenData, EsdtTokenType, ManagedAddress,
-        ManagedBuffer, ManagedByteArray, ManagedRefMut, ManagedType, ManagedVec, SystemSCAddress,
-        TokenIdentifier,
+        ManagedBuffer, ManagedByteArray, ManagedRef, ManagedRefMut, ManagedType, ManagedVec,
+        SystemSCAddress, TokenIdentifier,
     },
 };
 
@@ -386,8 +386,7 @@ where
                 big_int_temp_handle.clone(),
             );
 
-            let bu = BigUint::<A>::from_handle(big_int_temp_handle);
-            // TODO: forget bu
+            let bu = ManagedRef::<A, BigUint<A>>::wrap_handle(big_int_temp_handle); //  BigUint::<A>::from_handle(big_int_temp_handle);
             bu.to_u64().unwrap_or(255)
         }
     }
@@ -619,7 +618,7 @@ where
             result_handle.clone(),
         );
 
-        let result = unsafe { ManagedBuffer::<A>::from_handle(result_handle) };
+        let result = unsafe { ManagedRef::<A, ManagedBuffer<A>>::wrap_handle(result_handle) };
 
         // Decoding the response needs more research
         // Empty response means no address has transferRole for the token

framework/base/src/contract_base/wrappers/storage_raw_wrapper.rs

@@ -6,10 +6,7 @@ use crate::api::HandleConstraints;
 use crate::codec::{TopDecode, TopEncode};
 
 use crate::{
-    api::{
-        const_handles::MBUF_TEMPORARY_1, use_raw_handle, ErrorApi, ManagedTypeApi, StorageReadApi,
-        StorageReadApiImpl, StorageWriteApi,
-    },
+    api::{ErrorApi, ManagedTypeApi, StorageReadApi, StorageReadApiImpl, StorageWriteApi},
     storage::StorageKey,
     storage_get,
     storage_get::StorageGetErrorHandler,
@@ -59,8 +56,7 @@ where
         V: TopDecode,
     {
         let key: StorageKey<A> = storage_key.into();
-        let result_buffer =
-            unsafe { ManagedBuffer::<A>::from_handle(use_raw_handle(MBUF_TEMPORARY_1)) };
+        let result_buffer = unsafe { ManagedBuffer::<A>::new_uninit() };
         A::storage_read_api_impl().storage_load_from_address(
             address.get_handle(),
             key.get_handle(),

framework/base/src/storage/storage_set.rs

@@ -53,7 +53,7 @@ where
 
         let handle: A::ManagedBufferHandle = use_raw_handle(const_handles::MBUF_TEMPORARY_1);
         A::managed_type_impl().mb_from_small_int_unsigned(handle.clone(), value as i64);
-        let managed_buffer = unsafe { ManagedBuffer::from_handle(handle) };
+        let managed_buffer = unsafe { ManagedRef::wrap_handle(handle) };
         self.set_managed_buffer(&managed_buffer);
     }
 
@@ -63,7 +63,7 @@ where
 
         let handle: A::ManagedBufferHandle = use_raw_handle(const_handles::MBUF_TEMPORARY_1);
         A::managed_type_impl().mb_from_small_int_signed(handle.clone(), value);
-        let managed_buffer = unsafe { ManagedBuffer::from_handle(handle) };
+        let managed_buffer = unsafe { ManagedRef::wrap_handle(handle) };
         self.set_managed_buffer(&managed_buffer);
     }
 

framework/base/src/types/interaction/tx_data/function_call.rs

@@ -131,7 +131,7 @@ where
             MultiValueEncoded::<Api, ManagedBuffer<Api>>::multi_decode_or_handle_err(input, h)?;
         Ok(FunctionCall {
             function_name,
-            arg_buffer: args.to_arg_buffer(),
+            arg_buffer: args.into_arg_buffer(),
         })
     }
 }

framework/base/src/types/managed/basic/managed_buffer.rs

@@ -2,7 +2,7 @@ use crate::{
     abi::{TypeAbi, TypeAbiFrom, TypeName},
     api::{
         use_raw_handle, ErrorApiImpl, HandleConstraints, InvalidSliceError, ManagedBufferApiImpl,
-        ManagedTypeApi, RawHandle, StaticVarApiImpl,
+        ManagedTypeApi, ManagedTypeApiImpl, RawHandle, StaticVarApiImpl,
     },
     codec::{
         DecodeErrorHandler, Empty, EncodeErrorHandler, NestedDecode, NestedDecodeInput,
@@ -418,17 +418,15 @@ impl<M: ManagedTypeApi> ManagedBuffer<M> {
 
 impl<M: ManagedTypeApi> Clone for ManagedBuffer<M> {
     fn clone(&self) -> Self {
-        let api = M::managed_type_impl();
-        let clone_handle = api.mb_new_empty();
-        api.mb_append(clone_handle.clone(), self.handle.clone());
-        unsafe { ManagedBuffer::from_handle(clone_handle) }
+        let cloned = ManagedBuffer::new();
+        M::managed_type_impl().mb_append(cloned.get_handle(), self.handle.clone());
+        cloned
     }
 }
 
 impl<M: ManagedTypeApi> Drop for ManagedBuffer<M> {
     fn drop(&mut self) {
-        // TODO: enable, after fixing all ownership issues
-        // M::managed_type_impl().drop_managed_buffer(self.handle.clone());
+        M::managed_type_impl().drop_managed_buffer(self.handle.clone());
     }
 }
 

framework/base/src/types/managed/multi_value/egld_or_esdt_token_payment_multi_value.rs

@@ -39,7 +39,7 @@ impl<M: ManagedTypeApi> ManagedVecItem for EgldOrEsdtTokenPaymentMultiValue<M> {
     const SKIPS_RESERIALIZATION: bool = EgldOrEsdtTokenPayment::<M>::SKIPS_RESERIALIZATION;
     type Ref<'a> = ManagedVecRef<'a, Self>;
 
-    fn read_from_payload(payload: &Self::PAYLOAD) -> Self {
+    unsafe fn read_from_payload(payload: &Self::PAYLOAD) -> Self {
         EgldOrEsdtTokenPayment::read_from_payload(payload).into()
     }
 

framework/base/src/types/managed/multi_value/esdt_token_payment_multi_value.rs

@@ -45,7 +45,7 @@ impl<M: ManagedTypeApi> ManagedVecItem for EsdtTokenPaymentMultiValue<M> {
     const SKIPS_RESERIALIZATION: bool = EsdtTokenPayment::<M>::SKIPS_RESERIALIZATION;
     type Ref<'a> = ManagedVecRef<'a, Self>;
 
-    fn read_from_payload(payload: &Self::PAYLOAD) -> Self {
+    unsafe fn read_from_payload(payload: &Self::PAYLOAD) -> Self {
         EsdtTokenPayment::read_from_payload(payload).into()
     }
 

framework/base/src/types/managed/multi_value/multi_value_encoded.rs

@@ -17,7 +17,7 @@ use crate::{
     },
     contract_base::{ExitCodecErrorHandler, ManagedSerializer},
     err_msg,
-    types::{ManagedArgBuffer, ManagedBuffer, ManagedType, ManagedVec, ManagedVecItem},
+    types::{ManagedArgBuffer, ManagedBuffer, ManagedVec, ManagedVecItem},
 };
 use core::{iter::FromIterator, marker::PhantomData};
 
@@ -107,7 +107,11 @@ where
     M: ManagedTypeApi,
 {
     pub fn to_arg_buffer(&self) -> ManagedArgBuffer<M> {
-        unsafe { ManagedArgBuffer::from_handle(self.raw_buffers.get_handle()) }
+        ManagedArgBuffer::from(self.raw_buffers.clone())
+    }
+
+    pub fn into_arg_buffer(self) -> ManagedArgBuffer<M> {
+        ManagedArgBuffer::from(self.raw_buffers)
     }
 }
 

framework/base/src/types/managed/multi_value/multi_value_managed_vec_counted.rs

@@ -100,7 +100,7 @@ where
     const SKIPS_RESERIALIZATION: bool = false;
     type Ref<'a> = Self;
 
-    fn read_from_payload(payload: &Self::PAYLOAD) -> Self {
+    unsafe fn read_from_payload(payload: &Self::PAYLOAD) -> Self {
         Self::from(ManagedVec::<M, T>::read_from_payload(payload))
     }
 

framework/base/src/types/managed/wrapped/egld_or_esdt_token_payment.rs

@@ -205,7 +205,7 @@ impl<M: ManagedTypeApi> ManagedVecItem for EgldOrEsdtTokenPayment<M> {
     const SKIPS_RESERIALIZATION: bool = false;
     type Ref<'a> = ManagedVecRef<'a, Self>;
 
-    fn read_from_payload(payload: &Self::PAYLOAD) -> Self {
+    unsafe fn read_from_payload(payload: &Self::PAYLOAD) -> Self {
         let mut index = 0;
         unsafe {
             EgldOrEsdtTokenPayment {

framework/base/src/types/managed/wrapped/encoded_managed_vec_item.rs

@@ -14,7 +14,9 @@ where
     T: ManagedVecItem,
 {
     pub(crate) fn decode(&self) -> T {
-        T::read_from_payload(&self.encoded)
+        // TODO: not safe!!
+        // must revisit
+        unsafe { T::read_from_payload(&self.encoded) }
     }
 }