diff --git a/contracts/feature-tests/composability/forwarder-interactor/src/proxy.rs b/contracts/feature-tests/composability/forwarder-interactor/src/proxy.rs
index 71c3d237dc..c3912f1755 100644
--- a/contracts/feature-tests/composability/forwarder-interactor/src/proxy.rs
+++ b/contracts/feature-tests/composability/forwarder-interactor/src/proxy.rs
@@ -1456,7 +1456,7 @@ where
     >(
         self,
         index: Arg0,
-    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValue5<ManagedBuffer<Env::Api>, EgldOrEsdtTokenIdentifier<Env::Api>, u64, BigUint<Env::Api>, MultiValueManagedVec<Env::Api, ManagedBuffer<Env::Api>>>> {
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValue5<ManagedBuffer<Env::Api>, TokenId<Env::Api>, u64, NonZeroBigUint<Env::Api>, MultiValueManagedVec<Env::Api, ManagedBuffer<Env::Api>>>> {
         self.wrapped_tx
             .payment(NotPayable)
             .raw_call("callback_data_at_index")
@@ -1577,7 +1577,7 @@ where
         Arg0: ProxyArg<ManagedAddress<Env::Api>>,
         Arg1: ProxyArg<ManagedBuffer<Env::Api>>,
         Arg2: ProxyArg<u64>,
-        Arg3: ProxyArg<MultiValueEncoded<Env::Api, EsdtTokenPaymentMultiValue<Env::Api>>>,
+        Arg3: ProxyArg<MultiValueEncoded<Env::Api, PaymentMultiValue<Env::Api>>>,
     >(
         self,
         to: Arg0,
@@ -1749,8 +1749,8 @@ where
     Api: ManagedTypeApi,
 {
     pub callback_name: ManagedBuffer<Api>,
-    pub token_identifier: EgldOrEsdtTokenIdentifier<Api>,
+    pub token_identifier: TokenId<Api>,
     pub token_nonce: u64,
-    pub token_amount: BigUint<Api>,
+    pub token_amount: NonZeroBigUint<Api>,
     pub args: ManagedVec<Api, ManagedBuffer<Api>>,
 }
diff --git a/contracts/feature-tests/composability/forwarder-queue/src/forwarder_queue.rs b/contracts/feature-tests/composability/forwarder-queue/src/forwarder_queue.rs
index 73c337233d..d3acd13ad4 100644
--- a/contracts/feature-tests/composability/forwarder-queue/src/forwarder_queue.rs
+++ b/contracts/feature-tests/composability/forwarder-queue/src/forwarder_queue.rs
@@ -21,7 +21,7 @@ pub struct QueuedCall<M: ManagedTypeApi> {
     pub gas_limit: u64,
     pub endpoint_name: ManagedBuffer<M>,
     pub args: ManagedArgBuffer<M>,
-    pub payments: EgldOrMultiEsdtPayment<M>,
+    pub payments: PaymentVec<M>,
 }
 
 /// Testing multiple calls per transaction.
@@ -81,15 +81,10 @@ pub trait ForwarderQueue {
         to: ManagedAddress,
         gas_limit: u64,
         endpoint_name: ManagedBuffer,
-        token: EsdtTokenIdentifier,
-        amount: BigUint,
+        token: TokenId,
+        amount: NonZeroBigUint,
         args: MultiValueEncoded<ManagedBuffer>,
     ) {
-        let mut payment = ManagedVec::new();
-        payment.push(EsdtTokenPayment::new(token, 0, amount));
-
-        let payments = EgldOrMultiEsdtPayment::MultiEsdt(payment);
-
         let call_type = QueuedCallType::Promise;
         self.queued_calls().push_back(QueuedCall {
             call_type,
@@ -97,7 +92,7 @@ pub trait ForwarderQueue {
             gas_limit,
             endpoint_name,
             args: args.to_arg_buffer(),
-            payments,
+            payments: PaymentVec::from_single_item(Payment::new(token, 0, amount)),
         });
     }
 
@@ -123,21 +118,14 @@ pub trait ForwarderQueue {
         endpoint_name: ManagedBuffer,
         args: MultiValueEncoded<ManagedBuffer>,
     ) {
-        let payments = self.call_value().any_payment();
+        let payments = self.call_value().all();
 
-        match &payments {
-            EgldOrMultiEsdtPayment::Egld(egld_value) => {
-                self.add_queued_call_egld_event(&call_type, &to, &endpoint_name, egld_value);
-            }
-            EgldOrMultiEsdtPayment::MultiEsdt(esdt_payments) => {
-                self.add_queued_call_esdt_event(
-                    &call_type,
-                    &to,
-                    &endpoint_name,
-                    &esdt_payments.clone().into_multi_value(),
-                );
-            }
-        }
+        self.add_queued_call_event(
+            &call_type,
+            &to,
+            &endpoint_name,
+            &payments.clone().into_multi_value(),
+        );
 
         self.queued_calls().push_back(QueuedCall {
             call_type,
@@ -145,7 +133,7 @@ pub trait ForwarderQueue {
             gas_limit,
             endpoint_name,
             args: args.to_arg_buffer(),
-            payments,
+            payments: payments.clone(),
         });
     }
 
@@ -155,24 +143,12 @@ pub trait ForwarderQueue {
         while let Some(node) = self.queued_calls().pop_front() {
             let call = node.clone().into_value();
 
-            match &call.payments {
-                EgldOrMultiEsdtPayment::Egld(egld_value) => {
-                    self.forward_queued_call_egld_event(
-                        &call.call_type,
-                        &call.to,
-                        &call.endpoint_name,
-                        egld_value,
-                    );
-                }
-                EgldOrMultiEsdtPayment::MultiEsdt(esdt_payments) => {
-                    self.forward_queued_call_esdt_event(
-                        &call.call_type,
-                        &call.to,
-                        &call.endpoint_name,
-                        &esdt_payments.clone().into_multi_value(),
-                    );
-                }
-            };
+            self.forward_queued_call_payment_event(
+                &call.call_type,
+                &call.to,
+                &call.endpoint_name,
+                &call.payments.clone().into_multi_value(),
+            );
 
             let contract_call = self
                 .tx()
@@ -205,7 +181,7 @@ pub trait ForwarderQueue {
     #[label("promises-callback")]
     fn promises_callback_method(&self) {
         self.callback_count().update(|c| *c += 1);
-        let payments = self.call_value().any_payment();
+        let payments = self.call_value().all();
 
         let payments_data_string = self
             .tx()
@@ -225,42 +201,21 @@ pub trait ForwarderQueue {
     #[storage_mapper("callback_payments")]
     fn callback_payments(&self) -> SingleValueMapper<ManagedBuffer>;
 
-    #[event("forward_queued_callback")]
-    fn forward_queued_callback_event(&self);
-
-    #[event("forward_queued_call_egld")]
-    fn forward_queued_call_egld_event(
-        &self,
-        #[indexed] call_type: &QueuedCallType,
-        #[indexed] to: &ManagedAddress,
-        #[indexed] endpoint_name: &ManagedBuffer,
-        #[indexed] egld_value: &BigUint,
-    );
-
-    #[event("forward_queued_call_esdt")]
-    fn forward_queued_call_esdt_event(
-        &self,
-        #[indexed] call_type: &QueuedCallType,
-        #[indexed] to: &ManagedAddress,
-        #[indexed] endpoint_name: &ManagedBuffer,
-        #[indexed] multi_esdt: &MultiValueEncoded<EsdtTokenPaymentMultiValue>,
-    );
-
-    #[event("add_queued_call_egld")]
-    fn add_queued_call_egld_event(
+    #[event("forward_queued_call_payment")]
+    fn forward_queued_call_payment_event(
         &self,
         #[indexed] call_type: &QueuedCallType,
         #[indexed] to: &ManagedAddress,
         #[indexed] endpoint_name: &ManagedBuffer,
-        #[indexed] egld_value: &BigUint,
+        #[indexed] multi_esdt: &MultiValueEncoded<PaymentMultiValue>,
     );
 
-    #[event("add_queued_call_esdt")]
-    fn add_queued_call_esdt_event(
+    #[event("add_queued_call")]
+    fn add_queued_call_event(
         &self,
         #[indexed] call_type: &QueuedCallType,
         #[indexed] to: &ManagedAddress,
         #[indexed] endpoint_name: &ManagedBuffer,
-        #[indexed] multi_esdt: &MultiValueEncoded<EsdtTokenPaymentMultiValue>,
+        #[indexed] multi_esdt: &MultiValueEncoded<PaymentMultiValue>,
     );
 }
diff --git a/contracts/feature-tests/composability/forwarder/src/common.rs b/contracts/feature-tests/composability/forwarder/src/common.rs
index 5a47e21eaf..46b5517387 100644
--- a/contracts/feature-tests/composability/forwarder/src/common.rs
+++ b/contracts/feature-tests/composability/forwarder/src/common.rs
@@ -5,9 +5,9 @@ multiversx_sc::derive_imports!();
 #[derive(TopEncode, TopDecode, Debug)]
 pub struct CallbackData<M: ManagedTypeApi> {
     pub callback_name: ManagedBuffer<M>,
-    pub token_identifier: EgldOrEsdtTokenIdentifier<M>,
+    pub token_identifier: TokenId<M>,
     pub token_nonce: u64,
-    pub token_amount: BigUint<M>,
+    pub token_amount: NonZeroBigUint<M>,
     pub args: ManagedVec<M, ManagedBuffer<M>>,
 }
 
@@ -16,14 +16,11 @@ pub trait CommonModule {
     #[event("retrieve_funds_callback")]
     fn retrieve_funds_callback_event(
         &self,
-        #[indexed] token: &EgldOrEsdtTokenIdentifier,
+        #[indexed] token: &TokenId,
         #[indexed] nonce: u64,
-        #[indexed] payment: &BigUint,
+        #[indexed] payment: &NonZeroBigUint,
     );
 
-    #[event("callback_result")]
-    fn callback_result(&self, #[indexed] result: MultiValueEncoded<ManagedBuffer>);
-
     #[view]
     #[storage_mapper("callback_data")]
     fn callback_data(&self) -> VecMapper<CallbackData<Self::Api>>;
@@ -34,9 +31,9 @@ pub trait CommonModule {
         index: usize,
     ) -> MultiValue5<
         ManagedBuffer,
-        EgldOrEsdtTokenIdentifier,
+        TokenId,
         u64,
-        BigUint,
+        NonZeroBigUint,
         MultiValueManagedVec<Self::Api, ManagedBuffer>,
     > {
         let cb_data = self.callback_data().get(index);
diff --git a/contracts/feature-tests/composability/forwarder/src/forwarder_proxy.rs b/contracts/feature-tests/composability/forwarder/src/forwarder_proxy.rs
index 71c3d237dc..c3912f1755 100644
--- a/contracts/feature-tests/composability/forwarder/src/forwarder_proxy.rs
+++ b/contracts/feature-tests/composability/forwarder/src/forwarder_proxy.rs
@@ -1456,7 +1456,7 @@ where
     >(
         self,
         index: Arg0,
-    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValue5<ManagedBuffer<Env::Api>, EgldOrEsdtTokenIdentifier<Env::Api>, u64, BigUint<Env::Api>, MultiValueManagedVec<Env::Api, ManagedBuffer<Env::Api>>>> {
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValue5<ManagedBuffer<Env::Api>, TokenId<Env::Api>, u64, NonZeroBigUint<Env::Api>, MultiValueManagedVec<Env::Api, ManagedBuffer<Env::Api>>>> {
         self.wrapped_tx
             .payment(NotPayable)
             .raw_call("callback_data_at_index")
@@ -1577,7 +1577,7 @@ where
         Arg0: ProxyArg<ManagedAddress<Env::Api>>,
         Arg1: ProxyArg<ManagedBuffer<Env::Api>>,
         Arg2: ProxyArg<u64>,
-        Arg3: ProxyArg<MultiValueEncoded<Env::Api, EsdtTokenPaymentMultiValue<Env::Api>>>,
+        Arg3: ProxyArg<MultiValueEncoded<Env::Api, PaymentMultiValue<Env::Api>>>,
     >(
         self,
         to: Arg0,
@@ -1749,8 +1749,8 @@ where
     Api: ManagedTypeApi,
 {
     pub callback_name: ManagedBuffer<Api>,
-    pub token_identifier: EgldOrEsdtTokenIdentifier<Api>,
+    pub token_identifier: TokenId<Api>,
     pub token_nonce: u64,
-    pub token_amount: BigUint<Api>,
+    pub token_amount: NonZeroBigUint<Api>,
     pub args: ManagedVec<Api, ManagedBuffer<Api>>,
 }
diff --git a/contracts/feature-tests/composability/forwarder/src/fwd_call_async.rs b/contracts/feature-tests/composability/forwarder/src/fwd_call_async.rs
index d68e8ab88c..5aa64fd54b 100644
--- a/contracts/feature-tests/composability/forwarder/src/fwd_call_async.rs
+++ b/contracts/feature-tests/composability/forwarder/src/fwd_call_async.rs
@@ -126,16 +126,24 @@ pub trait ForwarderAsyncCallModule: common::CommonModule {
 
     #[callback]
     fn retrieve_funds_callback(&self) {
-        let (token, nonce, payment) = self.call_value().egld_or_single_esdt().into_tuple();
-        self.retrieve_funds_callback_event(&token, nonce, &payment);
-
-        let _ = self.callback_data().push(&CallbackData {
-            callback_name: ManagedBuffer::from(b"retrieve_funds_callback"),
-            token_identifier: token,
-            token_nonce: nonce,
-            token_amount: payment,
-            args: ManagedVec::new(),
-        });
+        self.async_callback_event();
+
+        let call_value = self.call_value().all();
+        for payment in &*call_value {
+            self.retrieve_funds_callback_event(
+                &payment.token_identifier,
+                payment.token_nonce,
+                &payment.amount,
+            );
+
+            let _ = self.callback_data().push(&CallbackData {
+                callback_name: ManagedBuffer::from(b"retrieve_funds_callback"),
+                token_identifier: payment.token_identifier.clone(),
+                token_nonce: payment.token_nonce,
+                token_amount: payment.amount.clone(),
+                args: ManagedVec::new(),
+            });
+        }
     }
 
     #[endpoint]
@@ -199,4 +207,7 @@ pub trait ForwarderAsyncCallModule: common::CommonModule {
             .payment(payment_args.convert_payment_multi_triples())
             .async_call_and_exit();
     }
+
+    #[event("async_callback")]
+    fn async_callback_event(&self);
 }
diff --git a/contracts/feature-tests/composability/forwarder/src/fwd_call_promise_direct.rs b/contracts/feature-tests/composability/forwarder/src/fwd_call_promise_direct.rs
index 40f18ce7af..255bf46d6b 100644
--- a/contracts/feature-tests/composability/forwarder/src/fwd_call_promise_direct.rs
+++ b/contracts/feature-tests/composability/forwarder/src/fwd_call_promise_direct.rs
@@ -48,19 +48,14 @@ pub trait CallPromisesDirectModule {
         to: ManagedAddress,
         endpoint_name: ManagedBuffer,
         extra_gas_for_callback: u64,
-        token_payment_args: MultiValueEncoded<EsdtTokenPaymentMultiValue>,
+        token_payment_args: MultiValueEncoded<PaymentMultiValue>,
     ) {
-        let mut token_payments_vec = ManagedVec::new();
-        for token_payment_arg in token_payment_args {
-            token_payments_vec.push(token_payment_arg.into_inner());
-        }
-
         let gas_limit = (self.blockchain().get_gas_left() - extra_gas_for_callback) * 9 / 10;
 
         self.tx()
             .to(&to)
             .raw_call(endpoint_name)
-            .payment(EgldOrMultiEsdtPayment::MultiEsdt(token_payments_vec))
+            .payment(MultiTransfer(token_payment_args.convert_payment()))
             .gas(gas_limit)
             .callback(self.callbacks().the_one_callback(2001, 2002u32.into()))
             .gas_for_callback(extra_gas_for_callback)
diff --git a/contracts/feature-tests/composability/forwarder/src/fwd_call_promises.rs b/contracts/feature-tests/composability/forwarder/src/fwd_call_promises.rs
index fac79cc9b0..8070dba861 100644
--- a/contracts/feature-tests/composability/forwarder/src/fwd_call_promises.rs
+++ b/contracts/feature-tests/composability/forwarder/src/fwd_call_promises.rs
@@ -44,22 +44,33 @@ pub trait CallPromisesModule: common::CommonModule {
 
     #[promises_callback]
     fn retrieve_funds_callback(&self) {
-        let (token, nonce, payment) = self.call_value().egld_or_single_esdt().into_tuple();
-        self.retrieve_funds_callback_event(&token, nonce, &payment);
-
-        let _ = self.callback_data().push(&CallbackData {
-            callback_name: ManagedBuffer::from(b"retrieve_funds_callback"),
-            token_identifier: token,
-            token_nonce: nonce,
-            token_amount: payment,
-            args: ManagedVec::new(),
-        });
+        self.promises_callback_event();
+
+        let call_value = self.call_value().all();
+        for payment in &*call_value {
+            self.retrieve_funds_callback_event(
+                &payment.token_identifier,
+                payment.token_nonce,
+                &payment.amount,
+            );
+
+            let _ = self.callback_data().push(&CallbackData {
+                callback_name: ManagedBuffer::from(b"retrieve_funds_callback"),
+                token_identifier: payment.token_identifier.clone(),
+                token_nonce: payment.token_nonce,
+                token_amount: payment.amount.clone(),
+                args: ManagedVec::new(),
+            });
+        }
     }
 
+    #[event("promises_callback")]
+    fn promises_callback_event(&self);
+
     #[endpoint]
     #[payable("*")]
     fn forward_payment_callback(&self, to: ManagedAddress) {
-        let payment = self.call_value().any_payment();
+        let payment = self.call_value().all();
         let gas_limit = self.blockchain().get_gas_left() / 2;
 
         self.tx()
@@ -73,7 +84,7 @@ pub trait CallPromisesModule: common::CommonModule {
     #[endpoint]
     #[payable("*")]
     fn forward_payment_gas_for_callback(&self, to: ManagedAddress) {
-        let payment = self.call_value().any_payment();
+        let payment = self.call_value().all();
         let half_gas = self.blockchain().get_gas_left() / 3;
 
         self.tx()
@@ -89,31 +100,24 @@ pub trait CallPromisesModule: common::CommonModule {
     fn transfer_callback(&self, #[call_result] result: MultiValueEncoded<ManagedBuffer>) {
         self.callback_result(result);
 
-        let call_value = self.call_value().any_payment();
-        match call_value {
-            EgldOrMultiEsdtPayment::Egld(egld) => {
-                self.retrieve_funds_callback_event(&EgldOrEsdtTokenIdentifier::egld(), 0, &egld);
-                let _ = self.callback_data().push(&CallbackData {
-                    callback_name: ManagedBuffer::from(b"transfer_callback"),
-                    token_identifier: EgldOrEsdtTokenIdentifier::egld(),
-                    token_nonce: 0,
-                    token_amount: egld,
-                    args: ManagedVec::new(),
-                });
-            }
-            EgldOrMultiEsdtPayment::MultiEsdt(multi_esdt) => {
-                for esdt in multi_esdt.into_iter() {
-                    let token_identifier = EgldOrEsdtTokenIdentifier::esdt(esdt.token_identifier);
-                    self.retrieve_funds_callback_event(&token_identifier, 0, &esdt.amount);
-                    let _ = self.callback_data().push(&CallbackData {
-                        callback_name: ManagedBuffer::from(b"transfer_callback"),
-                        token_identifier,
-                        token_nonce: 0,
-                        token_amount: esdt.amount,
-                        args: ManagedVec::new(),
-                    });
-                }
-            }
+        let call_value = self.call_value().all();
+        for payment in &*call_value {
+            self.retrieve_funds_callback_event(
+                &payment.token_identifier,
+                payment.token_nonce,
+                &payment.amount,
+            );
+
+            let _ = self.callback_data().push(&CallbackData {
+                callback_name: ManagedBuffer::from(b"transfer_callback"),
+                token_identifier: payment.token_identifier.clone(),
+                token_nonce: payment.token_nonce,
+                token_amount: payment.amount.clone(),
+                args: ManagedVec::new(),
+            });
         }
     }
+
+    #[event("callback_result")]
+    fn callback_result(&self, #[indexed] result: MultiValueEncoded<ManagedBuffer>);
 }
diff --git a/contracts/feature-tests/composability/forwarder/src/fwd_call_promises_bt.rs b/contracts/feature-tests/composability/forwarder/src/fwd_call_promises_bt.rs
index 2ed07df920..dedc267236 100644
--- a/contracts/feature-tests/composability/forwarder/src/fwd_call_promises_bt.rs
+++ b/contracts/feature-tests/composability/forwarder/src/fwd_call_promises_bt.rs
@@ -29,33 +29,19 @@ pub trait CallPromisesBackTransfersModule: common::CommonModule {
     #[promises_callback]
     fn retrieve_funds_back_transfers_callback(&self) {
         let back_transfers = self.blockchain().get_back_transfers();
-        let egld_transfer = back_transfers.egld_sum();
-
-        if egld_transfer != BigUint::zero() {
-            let egld_token_id = EgldOrEsdtTokenIdentifier::egld();
-            self.retrieve_funds_callback_event(&egld_token_id, 0, &egld_transfer);
-
-            let _ = self.callback_data().push(&CallbackData {
-                callback_name: ManagedBuffer::from(b"retrieve_funds_callback"),
-                token_identifier: egld_token_id,
-                token_nonce: 0,
-                token_amount: egld_transfer,
-                args: ManagedVec::new(),
-            });
-        }
-
-        for esdt_transfer in back_transfers.payments {
+        let bt_payments = back_transfers.into_payment_vec();
+        for payment in bt_payments {
             self.retrieve_funds_callback_event(
-                &esdt_transfer.token_identifier,
-                esdt_transfer.token_nonce,
-                &esdt_transfer.amount,
+                &payment.token_identifier,
+                payment.token_nonce,
+                &payment.amount,
             );
 
             let _ = self.callback_data().push(&CallbackData {
                 callback_name: ManagedBuffer::from(b"retrieve_funds_callback"),
-                token_identifier: esdt_transfer.token_identifier,
-                token_nonce: esdt_transfer.token_nonce,
-                token_amount: esdt_transfer.amount.clone(),
+                token_identifier: payment.token_identifier,
+                token_nonce: payment.token_nonce,
+                token_amount: payment.amount,
                 args: ManagedVec::new(),
             });
         }
diff --git a/contracts/feature-tests/composability/interact/src/forwarder_queue_proxy.rs b/contracts/feature-tests/composability/interact/src/forwarder_queue_proxy.rs
index 524906179c..6acc255e7e 100644
--- a/contracts/feature-tests/composability/interact/src/forwarder_queue_proxy.rs
+++ b/contracts/feature-tests/composability/interact/src/forwarder_queue_proxy.rs
@@ -132,8 +132,8 @@ where
         Arg0: ProxyArg<ManagedAddress<Env::Api>>,
         Arg1: ProxyArg<u64>,
         Arg2: ProxyArg<ManagedBuffer<Env::Api>>,
-        Arg3: ProxyArg<EsdtTokenIdentifier<Env::Api>>,
-        Arg4: ProxyArg<BigUint<Env::Api>>,
+        Arg3: ProxyArg<TokenId<Env::Api>>,
+        Arg4: ProxyArg<NonZeroBigUint<Env::Api>>,
         Arg5: ProxyArg<MultiValueEncoded<Env::Api, ManagedBuffer<Env::Api>>>,
     >(
         self,
@@ -238,7 +238,7 @@ where
     pub gas_limit: u64,
     pub endpoint_name: ManagedBuffer<Api>,
     pub args: ManagedArgBuffer<Api>,
-    pub payments: EgldOrMultiEsdtPayment<Api>,
+    pub payments: ManagedVec<Api, Payment<Api>>,
 }
 
 #[type_abi]
diff --git a/contracts/feature-tests/composability/scenarios/forw_queue_async.scen.json b/contracts/feature-tests/composability/scenarios/forw_queue_async.scen.json
index 041f030e5e..ac305c7482 100644
--- a/contracts/feature-tests/composability/scenarios/forw_queue_async.scen.json
+++ b/contracts/feature-tests/composability/scenarios/forw_queue_async.scen.json
@@ -58,10 +58,12 @@
                         "address": "sc:forwarder-queue",
                         "endpoint": "str:forward_queued_calls",
                         "topics": [
-                            "str:forward_queued_call_egld",
+                            "str:forward_queued_call_payment",
                             "1",
                             "sc:vault",
                             "str:accept_funds",
+                            "str:EGLD-000000",
+                            "0",
                             "1000"
                         ],
                         "data": "*"
diff --git a/contracts/feature-tests/composability/scenarios/forwarder_call_async_reject_egld.scen.json b/contracts/feature-tests/composability/scenarios/forwarder_call_async_reject_egld.scen.json
index 4f474d58ff..713a63ea68 100644
--- a/contracts/feature-tests/composability/scenarios/forwarder_call_async_reject_egld.scen.json
+++ b/contracts/feature-tests/composability/scenarios/forwarder_call_async_reject_egld.scen.json
@@ -20,7 +20,7 @@
         },
         {
             "step": "scCall",
-            "id": "2",
+            "id": "forward_async_reject_funds-EGLD",
             "comment": "tokens returned after a failed call do not currently show up as callback call value",
             "tx": {
                 "from": "address:a_user",
@@ -57,10 +57,7 @@
                         "address": "sc:forwarder",
                         "endpoint": "str:callBack",
                         "topics": [
-                            "str:retrieve_funds_callback",
-                            "str:EGLD",
-                            "",
-                            "0"
+                            "str:async_callback"
                         ],
                         "data": [
                             ""
diff --git a/contracts/feature-tests/composability/scenarios/forwarder_call_async_reject_esdt.scen.json b/contracts/feature-tests/composability/scenarios/forwarder_call_async_reject_esdt.scen.json
index 05f5463acb..7def486dde 100644
--- a/contracts/feature-tests/composability/scenarios/forwarder_call_async_reject_esdt.scen.json
+++ b/contracts/feature-tests/composability/scenarios/forwarder_call_async_reject_esdt.scen.json
@@ -23,7 +23,7 @@
         },
         {
             "step": "scCall",
-            "id": "2",
+            "id": "forward_async_reject_funds-single-ESDT",
             "comment": "tokens returned after a failed call do not currently show up as callback call value",
             "tx": {
                 "from": "address:a_user",
@@ -85,10 +85,7 @@
                         "address": "sc:forwarder",
                         "endpoint": "str:callBack",
                         "topics": [
-                            "str:retrieve_funds_callback",
-                            "str:EGLD",
-                            "",
-                            ""
+                            "str:async_callback"
                         ],
                         "data": [
                             ""
diff --git a/contracts/feature-tests/composability/scenarios/forwarder_call_async_retrieve_egld.scen.json b/contracts/feature-tests/composability/scenarios/forwarder_call_async_retrieve_egld.scen.json
index ecfae9b375..21c2ea9c58 100644
--- a/contracts/feature-tests/composability/scenarios/forwarder_call_async_retrieve_egld.scen.json
+++ b/contracts/feature-tests/composability/scenarios/forwarder_call_async_retrieve_egld.scen.json
@@ -93,12 +93,22 @@
                             "0x00"
                         ]
                     },
+                    {
+                        "address": "sc:forwarder",
+                        "endpoint": "str:callBack",
+                        "topics": [
+                            "str:async_callback"
+                        ],
+                        "data": [
+                            ""
+                        ]
+                    },
                     {
                         "address": "sc:forwarder",
                         "endpoint": "str:callBack",
                         "topics": [
                             "str:retrieve_funds_callback",
-                            "str:EGLD",
+                            "str:EGLD-000000",
                             "0",
                             "1000"
                         ],
diff --git a/contracts/feature-tests/composability/scenarios/forwarder_call_async_retrieve_esdt.scen.json b/contracts/feature-tests/composability/scenarios/forwarder_call_async_retrieve_esdt.scen.json
index caf1a68f68..2c6f74aa6e 100644
--- a/contracts/feature-tests/composability/scenarios/forwarder_call_async_retrieve_esdt.scen.json
+++ b/contracts/feature-tests/composability/scenarios/forwarder_call_async_retrieve_esdt.scen.json
@@ -87,6 +87,16 @@
                             "1000"
                         ]
                     },
+                    {
+                        "address": "sc:forwarder",
+                        "endpoint": "str:callBack",
+                        "topics": [
+                            "str:async_callback"
+                        ],
+                        "data": [
+                            ""
+                        ]
+                    },
                     {
                         "address": "sc:forwarder",
                         "endpoint": "str:callBack",
diff --git a/contracts/feature-tests/composability/scenarios/forwarder_call_async_retrieve_nft.scen.json b/contracts/feature-tests/composability/scenarios/forwarder_call_async_retrieve_nft.scen.json
index 9fee9ad370..306a7ffb3f 100644
--- a/contracts/feature-tests/composability/scenarios/forwarder_call_async_retrieve_nft.scen.json
+++ b/contracts/feature-tests/composability/scenarios/forwarder_call_async_retrieve_nft.scen.json
@@ -96,6 +96,16 @@
                             "sc:forwarder"
                         ]
                     },
+                    {
+                        "address": "sc:forwarder",
+                        "endpoint": "str:callBack",
+                        "topics": [
+                            "str:async_callback"
+                        ],
+                        "data": [
+                            ""
+                        ]
+                    },
                     {
                         "address": "sc:forwarder",
                         "endpoint": "str:callBack",
diff --git a/contracts/feature-tests/composability/scenarios/promises_call_async_retrieve_egld.scen.json b/contracts/feature-tests/composability/scenarios/promises_call_async_retrieve_egld.scen.json
index 0941d7a8dd..6e0660556c 100644
--- a/contracts/feature-tests/composability/scenarios/promises_call_async_retrieve_egld.scen.json
+++ b/contracts/feature-tests/composability/scenarios/promises_call_async_retrieve_egld.scen.json
@@ -92,12 +92,22 @@
                             "0x00"
                         ]
                     },
+                    {
+                        "address": "sc:forwarder",
+                        "endpoint": "str:retrieve_funds_callback",
+                        "topics": [
+                            "str:promises_callback"
+                        ],
+                        "data": [
+                            ""
+                        ]
+                    },
                     {
                         "address": "sc:forwarder",
                         "endpoint": "str:retrieve_funds_callback",
                         "topics": [
                             "str:retrieve_funds_callback",
-                            "str:EGLD",
+                            "str:EGLD-000000",
                             "0",
                             "1000"
                         ],
diff --git a/contracts/feature-tests/composability/scenarios/promises_call_async_retrieve_esdt.scen.json b/contracts/feature-tests/composability/scenarios/promises_call_async_retrieve_esdt.scen.json
index 983fbd0d7c..764d2e3f67 100644
--- a/contracts/feature-tests/composability/scenarios/promises_call_async_retrieve_esdt.scen.json
+++ b/contracts/feature-tests/composability/scenarios/promises_call_async_retrieve_esdt.scen.json
@@ -86,6 +86,16 @@
                             "1000"
                         ]
                     },
+                    {
+                        "address": "sc:forwarder",
+                        "endpoint": "str:retrieve_funds_callback",
+                        "topics": [
+                            "str:promises_callback"
+                        ],
+                        "data": [
+                            ""
+                        ]
+                    },
                     {
                         "address": "sc:forwarder",
                         "endpoint": "str:retrieve_funds_callback",
diff --git a/contracts/feature-tests/composability/scenarios/promises_call_transfer_callback_esdt.scen.json b/contracts/feature-tests/composability/scenarios/promises_call_transfer_callback_esdt.scen.json
index f13a9b74e1..552ebfb2bc 100644
--- a/contracts/feature-tests/composability/scenarios/promises_call_transfer_callback_esdt.scen.json
+++ b/contracts/feature-tests/composability/scenarios/promises_call_transfer_callback_esdt.scen.json
@@ -24,7 +24,7 @@
         },
         {
             "step": "scCall",
-            "id": "1",
+            "id": "forward_payment_callback-ESDT",
             "tx": {
                 "from": "address:a_user",
                 "to": "sc:forwarder",
@@ -84,19 +84,6 @@
                         "data": [
                             ""
                         ]
-                    },
-                    {
-                        "address": "sc:forwarder",
-                        "endpoint": "str:transfer_callback",
-                        "topics": [
-                            "str:retrieve_funds_callback",
-                            "str:EGLD",
-                            "",
-                            ""
-                        ],
-                        "data": [
-                            ""
-                        ]
                     }
                 ],
                 "gas": "*",
@@ -105,7 +92,7 @@
         },
         {
             "step": "scCall",
-            "id": "2",
+            "id": "forward_payment_gas_for_callback-ESDT",
             "tx": {
                 "from": "address:a_user",
                 "to": "sc:forwarder",
@@ -165,19 +152,6 @@
                         "data": [
                             ""
                         ]
-                    },
-                    {
-                        "address": "sc:forwarder",
-                        "endpoint": "str:transfer_callback",
-                        "topics": [
-                            "str:retrieve_funds_callback",
-                            "str:EGLD",
-                            "",
-                            ""
-                        ],
-                        "data": [
-                            ""
-                        ]
                     }
                 ],
                 "gas": "*",
@@ -207,23 +181,6 @@
                 "sc:forwarder": {
                     "nonce": "0",
                     "balance": "0",
-                    "storage": {
-                        "str:callback_data.len": "2",
-                        "str:callback_data.item|u32:1": [
-                            "nested:str:transfer_callback",
-                            "nested:str:EGLD",
-                            "u64:0",
-                            "u32:0",
-                            "u32:0"
-                        ],
-                        "str:callback_data.item|u32:2": [
-                            "nested:str:transfer_callback",
-                            "nested:str:EGLD",
-                            "u64:0",
-                            "u32:0",
-                            "u32:0"
-                        ]
-                    },
                     "code": "mxsc:../forwarder/output/forwarder.mxsc.json"
                 }
             }
diff --git a/contracts/feature-tests/composability/tests/composability_scenario_go_test.rs b/contracts/feature-tests/composability/tests/composability_scenario_go_test.rs
index 3106e0c979..de87e3e4b6 100644
--- a/contracts/feature-tests/composability/tests/composability_scenario_go_test.rs
+++ b/contracts/feature-tests/composability/tests/composability_scenario_go_test.rs
@@ -573,19 +573,16 @@ fn promises_call_async_accept_esdt_go() {
 }
 
 #[test]
-#[ignore = "TODO"]
 fn promises_call_async_retrieve_egld_go() {
     world().run("scenarios/promises_call_async_retrieve_egld.scen.json");
 }
 
 #[test]
-#[ignore = "TODO"]
 fn promises_call_async_retrieve_esdt_go() {
     world().run("scenarios/promises_call_async_retrieve_esdt.scen.json");
 }
 
 #[test]
-#[ignore = "TODO"]
 fn promises_call_callback_directly_go() {
     world().run("scenarios/promises_call_callback_directly.scen.json");
 }
diff --git a/contracts/feature-tests/composability/tests/composability_scenario_rs_forwarder_legacy_test.rs b/contracts/feature-tests/composability/tests/composability_scenario_rs_forwarder_legacy_test.rs
index 60e1e192d9..8c4d0d916e 100644
--- a/contracts/feature-tests/composability/tests/composability_scenario_rs_forwarder_legacy_test.rs
+++ b/contracts/feature-tests/composability/tests/composability_scenario_rs_forwarder_legacy_test.rs
@@ -70,16 +70,19 @@ fn legacy_forwarder_call_async_multi_transfer_rs() {
 }
 
 #[test]
+#[ignore = "no longer matching new implementation"]
 fn legacy_forwarder_call_async_retrieve_egld_rs() {
     world().run("scenarios/forwarder_call_async_retrieve_egld.scen.json");
 }
 
 #[test]
+#[ignore = "no longer matching new implementation"]
 fn legacy_forwarder_call_async_retrieve_esdt_rs() {
     world().run("scenarios/forwarder_call_async_retrieve_esdt.scen.json");
 }
 
 #[test]
+#[ignore = "no longer matching new implementation"]
 fn legacy_forwarder_call_async_retrieve_nft_rs() {
     world().run("scenarios/forwarder_call_async_retrieve_nft.scen.json");
 }
diff --git a/framework/base/src/contract_base/wrappers/call_value_wrapper.rs b/framework/base/src/contract_base/wrappers/call_value_wrapper.rs
index 7dd232fa08..2bf85bc9c4 100644
--- a/framework/base/src/contract_base/wrappers/call_value_wrapper.rs
+++ b/framework/base/src/contract_base/wrappers/call_value_wrapper.rs
@@ -317,6 +317,10 @@ where
     /// Accepts any sort of payment, which is either:
     /// - EGLD (can be zero in case of no payment whatsoever);
     /// - Multi-ESDT (one or more ESDT transfers).
+    #[deprecated(
+        note = "It comes from a time when only 1 EGLD payment, or ESDT multi-transfer was possible. This is no longer the case. Use `any` instead.",
+        since = "0.64.0"
+    )]
     pub fn any_payment(&self) -> EgldOrMultiEsdtPayment<A> {
         let esdt_transfers = self.all_esdt_transfers();
         if esdt_transfers.is_empty() {
diff --git a/framework/base/src/types/managed/wrapped/token/egld_or_multi_esdt_payment.rs b/framework/base/src/types/managed/wrapped/token/egld_or_multi_esdt_payment.rs
index 2d664e0cf3..6e0af0d472 100644
--- a/framework/base/src/types/managed/wrapped/token/egld_or_multi_esdt_payment.rs
+++ b/framework/base/src/types/managed/wrapped/token/egld_or_multi_esdt_payment.rs
@@ -14,6 +14,10 @@ use crate::derive::type_abi;
 /// Encodes any type of payment, which either:
 /// - EGLD (can be zero in case of no payment whatsoever);
 /// - Multi-ESDT (one or more ESDT transfers).
+#[deprecated(
+    note = "It comes from a time when only 1 EGLD payment, or ESDT multi-transfer was possible. This is no longer the case. Switch to `Payment` instead.",
+    since = "0.64.0"
+)]
 #[type_abi]
 #[derive(TopDecode, TopEncode, NestedDecode, NestedEncode, Clone, PartialEq, Eq, Debug)]
 pub enum EgldOrMultiEsdtPayment<M: ManagedTypeApi> {