replace contract_call and migrate to unified

contracts/examples/multisig/src/multisig_perform.rs

@@ -189,13 +189,14 @@ pub trait MultisigPerformModule:
                     &call_data.endpoint_name,
                     call_data.arguments.as_multi(),
                 );
-                self.send()
-                    .contract_call::<()>(call_data.to, call_data.endpoint_name)
-                    .with_egld_transfer(call_data.egld_amount)
-                    .with_raw_arguments(call_data.arguments.into())
-                    .async_call()
+
+                self.tx()
+                    .to(&call_data.to)
+                    .raw_call(call_data.endpoint_name)
+                    .arguments_raw(call_data.arguments.into())
+                    .egld(call_data.egld_amount)
                     .with_callback(self.callbacks().perform_async_call_callback())
-                    .call_and_exit()
+                    .async_call_and_exit();
             },
             Action::SCDeployFromSource {
                 amount,

contracts/examples/seed-nft-minter/src/distribution_module.rs

@@ -33,10 +33,11 @@ pub trait DistributionModule {
             if payment_amount == 0 {
                 continue;
             }
-            self.send()
-                .contract_call::<IgnoreValue>(distribution.address, distribution.endpoint)
-                .with_egld_or_single_esdt_transfer((token_id.clone(), token_nonce, payment_amount))
-                .with_gas_limit(distribution.gas_limit)
+            self.tx()
+                .to(&distribution.address)
+                .raw_call(distribution.endpoint)
+                .egld_or_single_esdt((token_id.clone(), token_nonce, payment_amount))
+                .gas(distribution.gas_limit)
                 .transfer_execute();
         }
     }

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

@@ -17,11 +17,11 @@ pub trait ForwarderRawAlterativeInit: super::forwarder_raw_common::ForwarderRawC
         endpoint_name: ManagedBuffer,
         args: MultiValueEncoded<ManagedBuffer>,
     ) {
-        self.send()
-            .contract_call::<()>(to, endpoint_name)
-            .with_raw_arguments(args.to_arg_buffer())
-            .async_call()
-            .call_and_exit();
+        self.tx()
+            .to(&to)
+            .raw_call(endpoint_name)
+            .arguments_raw(args.to_arg_buffer())
+            .async_call_and_exit();
     }
 
     /// Will not work, only written for VM testing.

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

@@ -33,11 +33,20 @@ pub trait ForwarderRawAsync: super::forwarder_raw_common::ForwarderRawCommon {
         payment_amount: BigUint,
         endpoint_name: ManagedBuffer,
         args: MultiValueEncoded<ManagedBuffer>,
-    ) -> ContractCallWithEgldOrSingleEsdt<Self::Api, ()> {
-        self.send()
-            .contract_call(to, endpoint_name)
-            .with_raw_arguments(args.to_arg_buffer())
-            .with_egld_or_single_esdt_transfer((payment_token, 0, payment_amount))
+    ) -> Tx<
+        TxScEnv<Self::Api>,
+        (),
+        ManagedAddress,
+        EgldOrEsdtTokenPayment<Self::Api>,
+        (),
+        FunctionCall<Self::Api>,
+        (),
+    > {
+        self.tx()
+            .to(to)
+            .raw_call(endpoint_name)
+            .arguments_raw(args.to_arg_buffer())
+            .egld_or_single_esdt((payment_token, 0, payment_amount))
     }
 
     #[endpoint]

contracts/feature-tests/composability/promises-features/src/call_promise_direct.rs

@@ -14,14 +14,15 @@ pub trait CallPromisesDirectModule {
         args: MultiValueEncoded<ManagedBuffer>,
     ) {
         let payment = self.call_value().egld_or_single_esdt();
-        self.send()
-            .contract_call::<()>(to, endpoint_name)
-            .with_egld_or_single_esdt_transfer(payment)
-            .with_raw_arguments(args.to_arg_buffer())
-            .with_gas_limit(gas_limit)
+        self.tx()
+            .to(&to)
+            .raw_call(endpoint_name)
+            .egld_or_single_esdt(payment)
+            .arguments_raw(args.to_arg_buffer())
+            .gas(gas_limit)
             .async_call_promise()
-            .with_extra_gas_for_callback(extra_gas_for_callback)
             .with_callback(self.callbacks().the_one_callback(1001, 1002u32.into()))
+            .gas_for_callback(extra_gas_for_callback)
             .register_promise();
     }
 
@@ -40,13 +41,14 @@ pub trait CallPromisesDirectModule {
 
         let gas_limit = (self.blockchain().get_gas_left() - extra_gas_for_callback) * 9 / 10;
 
-        self.send()
-            .contract_call::<()>(to, endpoint_name)
-            .with_multi_token_transfer(token_payments_vec)
-            .with_gas_limit(gas_limit)
+        self.tx()
+            .to(&to)
+            .raw_call(endpoint_name)
+            .egld_or_multi_esdt(EgldOrMultiEsdtPayment::MultiEsdt(token_payments_vec))
+            .gas(gas_limit)
             .async_call_promise()
-            .with_extra_gas_for_callback(extra_gas_for_callback)
             .with_callback(self.callbacks().the_one_callback(2001, 2002u32.into()))
+            .gas_for_callback(extra_gas_for_callback)
             .register_promise();
     }
 

contracts/feature-tests/composability/vault/src/vault.rs

@@ -150,10 +150,11 @@ pub trait Vault {
         for _ in 0..nr_callbacks {
             self.num_async_calls_sent_from_child().update(|c| *c += 1);
 
-            self.send()
-                .contract_call::<()>(caller.clone(), endpoint_name.clone())
-                .with_egld_or_single_esdt_transfer(return_payment.clone())
-                .with_gas_limit(self.blockchain().get_gas_left() / 2)
+            self.tx()
+                .to(&caller)
+                .raw_call(endpoint_name.clone())
+                .egld_or_single_esdt(return_payment.clone())
+                .gas(self.blockchain().get_gas_left() / 2)
                 .transfer_execute()
         }
     }

contracts/modules/src/governance/mod.rs

@@ -278,16 +278,12 @@ pub trait GovernanceModule:
         self.clear_proposal(proposal_id);
 
         for action in proposal.actions {
-            let mut contract_call = self
-                .send()
-                .contract_call::<()>(action.dest_address, action.function_name)
-                .with_gas_limit(action.gas_limit);
-
-            for arg in &action.arguments {
-                contract_call.push_raw_argument(arg);
-            }
-
-            contract_call.transfer_execute();
+            self.tx()
+                .to(&action.dest_address)
+                .raw_call(action.function_name)
+                .gas(action.gas_limit)
+                .arguments_raw(action.arguments.into())
+                .transfer_execute()
         }
 
         self.proposal_executed_event(proposal_id);