MultiTransfer marker

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

@@ -97,7 +97,7 @@ impl ManagedTypeContainer {
         let mut num_bytes_copied = 0;
         let data = self.mb_get(source_handle);
         assert!(
-            data.len() % 4 == 0,
+            data.len().is_multiple_of(4),
             "malformed ManagedVec<ManagedBuffer> data"
         );
         for chunk in data.chunks(4) {
@@ -134,7 +134,7 @@ impl ManagedTypeContainer {
         let mut num_bytes_copied = 0;
         let data = self.mb_get(source_handle);
         assert!(
-            data.len() % 16 == 0,
+            data.len().is_multiple_of(16),
             "malformed ManagedVec<EsdtTokenPayment> data"
         );
         for chunk in data.chunks(16) {

contracts/core/price-aggregator/src/median.rs

@@ -11,7 +11,7 @@ pub fn calculate<M: ManagedTypeApi>(
     list.sort_unstable();
     let len = list.len();
     let middle_index = len / 2;
-    if len % 2 == 0 {
+    if len.is_multiple_of(2) {
         let median1 = list.get(middle_index - 1).ok_or("median1 invalid index")?;
         let median2 = list.get(middle_index).ok_or("median2 invalid index")?;
         Result::Ok(Some((median1.clone() + median2.clone()) / 2u64))

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

@@ -57,7 +57,7 @@ pub trait ForwarderAsyncCallModule {
     #[endpoint]
     #[payable("*")]
     fn forward_async_accept_funds(&self, to: ManagedAddress) {
-        let payment = self.call_value().single_optional();
+        let payment = self.call_value().all();
         self.vault_proxy()
             .contract(to)
             .accept_funds()

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

@@ -10,12 +10,12 @@ pub trait ForwarderRawAsync: super::forwarder_raw_common::ForwarderRawCommon {
         endpoint_name: ManagedBuffer,
         args: MultiValueEncoded<ManagedBuffer>,
     ) {
-        let opt_payment = self.call_value().single_optional();
+        let payment = self.call_value().all();
         self.tx()
             .to(to)
             .raw_call(endpoint_name)
             .arguments_raw(args.to_arg_buffer())
-            .payment(opt_payment)
+            .payment(payment)
             .async_call_and_exit()
     }
 

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

@@ -49,7 +49,7 @@ pub trait ForwarderAsyncCallModule: common::CommonModule {
     #[endpoint]
     #[payable("*")]
     fn forward_async_accept_funds(&self, to: ManagedAddress) {
-        let payment = self.call_value().single_optional();
+        let payment = self.call_value().all();
         self.tx()
             .to(&to)
             .typed(vault_proxy::VaultProxy)
@@ -119,7 +119,7 @@ pub trait ForwarderAsyncCallModule: common::CommonModule {
             .to(&to)
             .typed(vault_proxy::VaultProxy)
             .reject_funds()
-            .payment(payment)
+            .payment(MultiTransfer(payment))
             .callback(self.callbacks().retrieve_funds_callback())
             .async_call_and_exit()
     }

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

@@ -10,7 +10,7 @@ pub trait CallPromisesModule: common::CommonModule {
     #[endpoint]
     #[payable("*")]
     fn forward_promise_accept_funds(&self, to: ManagedAddress) {
-        let payment = self.call_value().single_optional();
+        let payment = self.call_value().all();
         let gas_limit = self.blockchain().get_gas_left() / 2;
 
         self.tx()

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

@@ -61,7 +61,7 @@ pub trait ForwarderSyncCallModule {
     #[endpoint]
     #[payable("*")]
     fn forward_sync_accept_funds(&self, to: ManagedAddress) {
-        let payment = self.call_value().single_optional();
+        let payment = self.call_value().all();
         let half_gas = self.blockchain().get_gas_left() / 2;
 
         let result = self
@@ -168,7 +168,7 @@ pub trait ForwarderSyncCallModule {
     #[endpoint]
     #[payable("*")]
     fn forward_sync_accept_funds_then_read(&self, to: ManagedAddress) -> usize {
-        let payment = self.call_value().single_optional();
+        let payment = self.call_value().all();
         self.tx()
             .to(&to)
             .typed(vault_proxy::VaultProxy)

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

@@ -9,7 +9,7 @@ pub trait ForwarderTransferExecuteModule {
     #[endpoint]
     #[payable]
     fn forward_transf_exec_accept_funds(&self, to: ManagedAddress) {
-        let payment = self.call_value().single_optional();
+        let payment = self.call_value().all();
         self.tx()
             .to(&to)
             .typed(vault_proxy::VaultProxy)

framework/base/src/types/interaction/tx_payment.rs

@@ -7,16 +7,17 @@ mod tx_payment_egld_or_multi_esdt_refs;
 mod tx_payment_egld_value;
 mod tx_payment_multi_egld_or_esdt;
 mod tx_payment_multi_esdt;
+mod tx_payment_multi_transfer_marker;
 mod tx_payment_none;
 mod tx_payment_not_payable;
 mod tx_payment_payment;
 mod tx_payment_payment_option;
 mod tx_payment_payment_ref;
 mod tx_payment_payment_refs;
-mod tx_payment_payment_vec;
 mod tx_payment_single_esdt;
 mod tx_payment_single_esdt_ref;
 mod tx_payment_single_esdt_triple;
+mod tx_payment_vec_ref;
 
 pub use test_esdt_transfer::TestEsdtTransfer;
 pub use tx_payment_egld::{Egld, EgldPayment};

framework/base/src/types/interaction/tx_payment/tx_payment_multi_transfer_marker.rs

@@ -0,0 +1,80 @@
+use crate::{
+    contract_base::{SendRawWrapper, TransferExecuteFailed},
+    types::{BigUint, ManagedAddress, MultiTransfer, PaymentVec, TxFrom, TxToSpecified},
+};
+
+use super::{FullPaymentData, FunctionCall, TxEnv, TxPayment};
+
+impl<Env, P> TxPayment<Env> for MultiTransfer<P>
+where
+    Env: TxEnv,
+    P: AsRef<PaymentVec<Env::Api>>,
+{
+    fn is_no_payment(&self, _env: &Env) -> bool {
+        let pv = self.0.as_ref();
+        pv.is_empty()
+    }
+
+    fn perform_transfer_execute_fallible(
+        self,
+        _env: &Env,
+        to: &ManagedAddress<Env::Api>,
+        gas_limit: u64,
+        fc: FunctionCall<Env::Api>,
+    ) -> Result<(), TransferExecuteFailed> {
+        let pv = self.0.as_ref();
+        SendRawWrapper::<Env::Api>::new().multi_egld_or_esdt_transfer_execute_fallible(
+            to,
+            pv.as_multi_egld_or_esdt_payment(),
+            gas_limit,
+            &fc.function_name,
+            &fc.arg_buffer,
+        )
+    }
+
+    fn perform_transfer_execute_legacy(
+        self,
+        _env: &Env,
+        to: &ManagedAddress<Env::Api>,
+        gas_limit: u64,
+        fc: FunctionCall<Env::Api>,
+    ) {
+        let pv = self.0.as_ref();
+        SendRawWrapper::<Env::Api>::new().multi_egld_or_esdt_transfer_execute(
+            to,
+            pv.as_multi_egld_or_esdt_payment(),
+            gas_limit,
+            &fc.function_name,
+            &fc.arg_buffer,
+        );
+    }
+
+    fn with_normalized<From, To, F, R>(
+        self,
+        env: &Env,
+        from: &From,
+        to: To,
+        fc: FunctionCall<Env::Api>,
+        f: F,
+    ) -> R
+    where
+        From: TxFrom<Env>,
+        To: TxToSpecified<Env>,
+        F: FnOnce(&ManagedAddress<Env::Api>, &BigUint<Env::Api>, FunctionCall<Env::Api>) -> R,
+    {
+        let pv = self.0.as_ref();
+        to.with_address_ref(env, |to_addr| {
+            let fc_conv =
+                fc.convert_to_multi_transfer_esdt_call(to_addr, pv.as_multi_egld_or_esdt_payment());
+            f(&from.resolve_address(env), &*BigUint::zero_ref(), fc_conv)
+        })
+    }
+
+    fn into_full_payment_data(self, _env: &Env) -> FullPaymentData<Env::Api> {
+        let pv = self.0.as_ref();
+        FullPaymentData {
+            egld: None,
+            multi_esdt: pv.as_multi_egld_or_esdt_payment().clone(),
+        }
+    }
+}

framework/base/src/types/interaction/tx_payment/tx_payment_payment_ref.rs

@@ -5,108 +5,66 @@ use crate::{
 
 use super::{FullPaymentData, FunctionCall, TxEnv, TxPayment};
 
-impl<Env> TxPayment<Env> for &Payment<Env::Api>
-where
-    Env: TxEnv,
-{
-    #[inline]
-    fn is_no_payment(&self, _env: &Env) -> bool {
-        // amount is NonZeroBigUint
-        false
-    }
+macro_rules! impl_txpayment_for_payment_ref {
+    ($ty:ty) => {
+        impl<Env> TxPayment<Env> for $ty
+        where
+            Env: TxEnv,
+        {
+            #[inline]
+            fn is_no_payment(&self, _env: &Env) -> bool {
+                // amount is NonZeroBigUint
+                false
+            }
 
-    fn perform_transfer_execute_fallible(
-        self,
-        env: &Env,
-        to: &ManagedAddress<Env::Api>,
-        gas_limit: u64,
-        fc: FunctionCall<Env::Api>,
-    ) -> Result<(), TransferExecuteFailed> {
-        self.as_refs()
-            .perform_transfer_execute_fallible(env, to, gas_limit, fc)
-    }
+            fn perform_transfer_execute_fallible(
+                self,
+                env: &Env,
+                to: &ManagedAddress<Env::Api>,
+                gas_limit: u64,
+                fc: FunctionCall<Env::Api>,
+            ) -> Result<(), TransferExecuteFailed> {
+                self.as_refs()
+                    .perform_transfer_execute_fallible(env, to, gas_limit, fc)
+            }
 
-    fn perform_transfer_execute_legacy(
-        self,
-        env: &Env,
-        to: &ManagedAddress<Env::Api>,
-        gas_limit: u64,
-        fc: FunctionCall<Env::Api>,
-    ) {
-        self.as_refs()
-            .perform_transfer_execute_legacy(env, to, gas_limit, fc)
-    }
+            fn perform_transfer_execute_legacy(
+                self,
+                env: &Env,
+                to: &ManagedAddress<Env::Api>,
+                gas_limit: u64,
+                fc: FunctionCall<Env::Api>,
+            ) {
+                self.as_refs()
+                    .perform_transfer_execute_legacy(env, to, gas_limit, fc)
+            }
 
-    fn with_normalized<From, To, F, R>(
-        self,
-        env: &Env,
-        from: &From,
-        to: To,
-        fc: FunctionCall<Env::Api>,
-        f: F,
-    ) -> R
-    where
-        From: TxFrom<Env>,
-        To: TxToSpecified<Env>,
-        F: FnOnce(&ManagedAddress<Env::Api>, &BigUint<Env::Api>, FunctionCall<Env::Api>) -> R,
-    {
-        self.as_refs().with_normalized(env, from, to, fc, f)
-    }
+            fn with_normalized<From, To, F, R>(
+                self,
+                env: &Env,
+                from: &From,
+                to: To,
+                fc: FunctionCall<Env::Api>,
+                f: F,
+            ) -> R
+            where
+                From: TxFrom<Env>,
+                To: TxToSpecified<Env>,
+                F: FnOnce(
+                    &ManagedAddress<Env::Api>,
+                    &BigUint<Env::Api>,
+                    FunctionCall<Env::Api>,
+                ) -> R,
+            {
+                self.as_refs().with_normalized(env, from, to, fc, f)
+            }
 
-    fn into_full_payment_data(self, env: &Env) -> FullPaymentData<Env::Api> {
-        self.as_refs().into_full_payment_data(env)
-    }
+            fn into_full_payment_data(self, env: &Env) -> FullPaymentData<Env::Api> {
+                self.as_refs().into_full_payment_data(env)
+            }
+        }
+    };
 }
 
-impl<Env> TxPayment<Env> for Ref<'_, Payment<Env::Api>>
-where
-    Env: TxEnv,
-{
-    #[inline]
-    fn is_no_payment(&self, _env: &Env) -> bool {
-        // amount is NonZeroBigUint
-        false
-    }
-
-    fn perform_transfer_execute_fallible(
-        self,
-        env: &Env,
-        to: &ManagedAddress<Env::Api>,
-        gas_limit: u64,
-        fc: FunctionCall<Env::Api>,
-    ) -> Result<(), TransferExecuteFailed> {
-        self.as_refs()
-            .perform_transfer_execute_fallible(env, to, gas_limit, fc)
-    }
-
-    fn perform_transfer_execute_legacy(
-        self,
-        env: &Env,
-        to: &ManagedAddress<Env::Api>,
-        gas_limit: u64,
-        fc: FunctionCall<Env::Api>,
-    ) {
-        self.as_refs()
-            .perform_transfer_execute_legacy(env, to, gas_limit, fc)
-    }
-
-    fn with_normalized<From, To, F, R>(
-        self,
-        env: &Env,
-        from: &From,
-        to: To,
-        fc: FunctionCall<Env::Api>,
-        f: F,
-    ) -> R
-    where
-        From: TxFrom<Env>,
-        To: TxToSpecified<Env>,
-        F: FnOnce(&ManagedAddress<Env::Api>, &BigUint<Env::Api>, FunctionCall<Env::Api>) -> R,
-    {
-        self.as_refs().with_normalized(env, from, to, fc, f)
-    }
-
-    fn into_full_payment_data(self, env: &Env) -> FullPaymentData<Env::Api> {
-        self.as_refs().into_full_payment_data(env)
-    }
-}
+impl_txpayment_for_payment_ref!(&Payment<Env::Api>);
+impl_txpayment_for_payment_ref!(Ref<'_, Payment<Env::Api>>);