contracts migration to new proxies and unified syntax

contracts/examples/proxy-pause/src/pause_sc_proxy.rs

@@ -0,0 +1,55 @@
+use multiversx_sc::proxy_imports::*;
+
+pub struct PausableProxy;
+
+impl<Env, From, To, Gas> TxProxyTrait<Env, From, To, Gas> for PausableProxy
+where
+    Env: TxEnv,
+    From: TxFrom<Env>,
+    To: TxTo<Env>,
+    Gas: TxGas<Env>,
+{
+    type TxProxyMethods = PausableProxyMethods<Env, From, To, Gas>;
+
+    fn proxy_methods(self, tx: Tx<Env, From, To, (), Gas, (), ()>) -> Self::TxProxyMethods {
+        PausableProxyMethods { wrapped_tx: tx }
+    }
+}
+
+pub struct PausableProxyMethods<Env, From, To, Gas>
+where
+    Env: TxEnv,
+    From: TxFrom<Env>,
+    To: TxTo<Env>,
+    Gas: TxGas<Env>,
+{
+    wrapped_tx: Tx<Env, From, To, (), Gas, (), ()>,
+}
+
+#[rustfmt::skip]
+impl<Env, From, To, Gas> PausableProxyMethods<Env, From, To, Gas>
+where
+    Env: TxEnv,
+    Env::Api: VMApi,
+    From: TxFrom<Env>,
+    To: TxTo<Env>,
+    Gas: TxGas<Env>,
+{
+    pub fn pause(
+        self,
+    ) -> TxProxyCall<Env, From, To, Gas, ()> {
+        self.wrapped_tx
+            .raw_call()
+            .function_name("pause")
+            .original_result()
+    }
+
+    pub fn unpause(
+        self,
+    ) -> TxProxyCall<Env, From, To, Gas, ()> {
+        self.wrapped_tx
+            .raw_call()
+            .function_name("unpause")
+            .original_result()
+    }
+}

contracts/examples/proxy-pause/src/proxy_pause.rs

@@ -1,17 +1,7 @@
 #![no_std]
 
 use multiversx_sc::imports::*;
-
-mod pause_proxy {
-    #[multiversx_sc::proxy]
-    pub trait Pausable {
-        #[endpoint]
-        fn pause(&self);
-
-        #[endpoint]
-        fn unpause(&self);
-    }
-}
+pub mod pause_sc_proxy;
 
 #[multiversx_sc::contract]
 pub trait PauseProxy {
@@ -46,23 +36,26 @@ pub trait PauseProxy {
 
     fn for_each_contract<F>(&self, f: F)
     where
-        F: Fn(pause_proxy::ProxyTo<Self::Api>),
+        F: Fn(pause_sc_proxy::PausableProxyMethods<TxScEnv<Self::Api>, (), &ManagedAddress, ()>),
     {
         for contract_address in self.contracts().iter() {
-            f(self.pausable_contract().contract(contract_address));
+            f(self
+                .tx()
+                .to(&contract_address)
+                .typed(pause_sc_proxy::PausableProxy));
         }
     }
 
     #[endpoint]
     fn pause(&self) {
         self.require_owner();
-        self.for_each_contract(|mut contract| contract.pause().execute_on_dest_context());
+        self.for_each_contract(|contract| contract.pause().sync_call());
     }
 
     #[endpoint]
     fn unpause(&self) {
         self.require_owner();
-        self.for_each_contract(|mut contract| contract.unpause().execute_on_dest_context());
+        self.for_each_contract(|contract| contract.unpause().sync_call());
     }
 
     fn require_owner(&self) {
@@ -79,7 +72,4 @@ pub trait PauseProxy {
     #[view]
     #[storage_mapper("contracts")]
     fn contracts(&self) -> SetMapper<ManagedAddress>;
-
-    #[proxy]
-    fn pausable_contract(&self) -> pause_proxy::Proxy<Self::Api>;
 }

contracts/feature-tests/basic-features/src/codec_err_test.rs

@@ -1,20 +1,6 @@
 multiversx_sc::imports!();
 use crate::types::CodecErrorTestType;
 
-mod encode_err_proxy {
-    multiversx_sc::imports!();
-    use crate::types::CodecErrorTestType;
-
-    #[multiversx_sc::proxy]
-    pub trait EncodeErrorProxy {
-        #[init]
-        fn init(&self, error_arg: CodecErrorTestType);
-
-        #[endpoint]
-        fn encode_error_method(&self, error_arg: CodecErrorTestType);
-    }
-}
-
 /// Test various serialization errors.
 #[multiversx_sc::module]
 pub trait CodecErrorTest {
@@ -62,24 +48,17 @@ pub trait CodecErrorTest {
     fn codec_err_event_data(&self) {
         self.event_err_data(CodecErrorTestType);
     }
-
-    #[proxy]
-    fn encode_err_proxy(&self) -> encode_err_proxy::Proxy<Self::Api>;
-
     /// Never actually calls any deploy/upgrade, so it is appropriate in this contract.
     /// It just covers contract init serialization errors.
     #[endpoint]
     fn codec_err_contract_init(&self) {
-        let _ = self.encode_err_proxy().init(CodecErrorTestType);
+        let _ = self.tx().raw_deploy().argument(&CodecErrorTestType);
     }
 
     /// Never actually calls any async/sync call, so it is appropriate in this contract.
     /// It just covers contract call serialization errors.
     #[endpoint]
     fn codec_err_contract_call(&self) {
-        let _ = self
-            .encode_err_proxy()
-            .contract(ManagedAddress::zero())
-            .encode_error_method(CodecErrorTestType);
+        let _ = self.tx().raw_call().argument(&CodecErrorTestType);
     }
 }

contracts/feature-tests/composability/builtin-func-features/src/builtin_func_features.rs

@@ -7,25 +7,26 @@ multiversx_sc::imports!();
 /// Test contract for investigating async calls.
 #[multiversx_sc::contract]
 pub trait BuiltinFuncFeatures {
-    #[proxy]
-    fn builtin_func_proxy(&self, to: ManagedAddress) -> builtin_func_proxy::Proxy<Self::Api>;
-
     #[init]
     fn init(&self) {}
 
     #[endpoint]
     fn call_set_user_name(&self, address: ManagedAddress, name: ManagedBuffer) {
-        self.builtin_func_proxy(address)
-            .set_user_name(&name)
+        self.tx()
+            .to(&address)
+            .typed(builtin_func_proxy::UserBuiltinProxy)
+            .set_user_name(name)
             .async_call()
             .call_and_exit()
     }
 
     #[endpoint]
     fn call_delete_user_name(&self, address: ManagedAddress) {
-        self.builtin_func_proxy(address)
+        self.tx()
+            .to(&address)
+            .typed(builtin_func_proxy::UserBuiltinProxy)
             .delete_user_name()
             .async_call()
-            .call_and_exit();
+            .call_and_exit()
     }
 }

contracts/feature-tests/composability/builtin-func-features/src/builtin_func_proxy.rs

@@ -1,10 +1,68 @@
-multiversx_sc::imports!();
+// Code generated by the multiversx-sc proxy generator. DO NOT EDIT.
 
-#[multiversx_sc::derive::proxy]
-pub trait UserBuiltin {
-    #[endpoint(SetUserName)]
-    fn set_user_name(&self, name: &ManagedBuffer);
+////////////////////////////////////////////////////
+////////////////// AUTO-GENERATED //////////////////
+////////////////////////////////////////////////////
 
-    #[endpoint(DeleteUserName)]
-    fn delete_user_name(&self);
+#![allow(dead_code)]
+#![allow(clippy::all)]
+
+use multiversx_sc::proxy_imports::*;
+
+pub struct UserBuiltinProxy;
+
+impl<Env, From, To, Gas> TxProxyTrait<Env, From, To, Gas> for UserBuiltinProxy
+where
+    Env: TxEnv,
+    From: TxFrom<Env>,
+    To: TxTo<Env>,
+    Gas: TxGas<Env>,
+{
+    type TxProxyMethods = UserBuiltinProxyMethods<Env, From, To, Gas>;
+
+    fn proxy_methods(self, tx: Tx<Env, From, To, (), Gas, (), ()>) -> Self::TxProxyMethods {
+        UserBuiltinProxyMethods { wrapped_tx: tx }
+    }
+}
+
+pub struct UserBuiltinProxyMethods<Env, From, To, Gas>
+where
+    Env: TxEnv,
+    From: TxFrom<Env>,
+    To: TxTo<Env>,
+    Gas: TxGas<Env>,
+{
+    wrapped_tx: Tx<Env, From, To, (), Gas, (), ()>,
+}
+
+#[rustfmt::skip]
+impl<Env, From, To, Gas> UserBuiltinProxyMethods<Env, From, To, Gas>
+where
+    Env: TxEnv,
+    Env::Api: VMApi,
+    From: TxFrom<Env>,
+    To: TxTo<Env>,
+    Gas: TxGas<Env>,
+{
+    pub fn set_user_name<
+        Arg0: CodecInto<ManagedBuffer<Env::Api>>,
+    >(
+        self,
+        name: Arg0,
+    ) -> TxProxyCall<Env, From, To, Gas, ()> {
+        self.wrapped_tx
+            .raw_call()
+            .function_name("SetUserName")
+            .argument(&name)
+            .original_result()
+    }
+
+    pub fn delete_user_name(
+        self,
+    ) -> TxProxyCall<Env, From, To, Gas, ()> {
+        self.wrapped_tx
+            .raw_call()
+            .function_name("DeleteUserName")
+            .original_result()
+    }
 }

contracts/feature-tests/composability/execute-on-dest-esdt-issue-callback/child/sc-config.toml

@@ -0,0 +1,2 @@
+[settings]
+proxy-paths = ["../parent/src/child_proxy.rs"]

contracts/feature-tests/composability/execute-on-dest-esdt-issue-callback/parent/src/child_proxy.rs

@@ -0,0 +1,102 @@
+// Code generated by the multiversx-sc proxy generator. DO NOT EDIT.
+
+////////////////////////////////////////////////////
+////////////////// AUTO-GENERATED //////////////////
+////////////////////////////////////////////////////
+
+#![allow(dead_code)]
+#![allow(clippy::all)]
+
+use multiversx_sc::proxy_imports::*;
+
+pub struct ChildProxy;
+
+impl<Env, From, To, Gas> TxProxyTrait<Env, From, To, Gas> for ChildProxy
+where
+    Env: TxEnv,
+    From: TxFrom<Env>,
+    To: TxTo<Env>,
+    Gas: TxGas<Env>,
+{
+    type TxProxyMethods = ChildProxyMethods<Env, From, To, Gas>;
+
+    fn proxy_methods(self, tx: Tx<Env, From, To, (), Gas, (), ()>) -> Self::TxProxyMethods {
+        ChildProxyMethods { wrapped_tx: tx }
+    }
+}
+
+pub struct ChildProxyMethods<Env, From, To, Gas>
+where
+    Env: TxEnv,
+    From: TxFrom<Env>,
+    To: TxTo<Env>,
+    Gas: TxGas<Env>,
+{
+    wrapped_tx: Tx<Env, From, To, (), Gas, (), ()>,
+}
+
+#[rustfmt::skip]
+impl<Env, From, Gas> ChildProxyMethods<Env, From, (), Gas>
+where
+    Env: TxEnv,
+    Env::Api: VMApi,
+    From: TxFrom<Env>,
+    Gas: TxGas<Env>,
+{
+    pub fn init(
+        self,
+    ) -> TxProxyDeploy<Env, From, Gas, ()> {
+        self.wrapped_tx
+            .raw_deploy()
+            .original_result()
+    }
+}
+
+#[rustfmt::skip]
+impl<Env, From, To, Gas> ChildProxyMethods<Env, From, To, Gas>
+where
+    Env: TxEnv,
+    Env::Api: VMApi,
+    From: TxFrom<Env>,
+    To: TxTo<Env>,
+    Gas: TxGas<Env>,
+{
+}
+
+#[rustfmt::skip]
+impl<Env, From, To, Gas> ChildProxyMethods<Env, From, To, Gas>
+where
+    Env: TxEnv,
+    Env::Api: VMApi,
+    From: TxFrom<Env>,
+    To: TxTo<Env>,
+    Gas: TxGas<Env>,
+{
+    pub fn issue_wrapped_egld<
+        Arg0: CodecInto<ManagedBuffer<Env::Api>>,
+        Arg1: CodecInto<ManagedBuffer<Env::Api>>,
+        Arg2: CodecInto<BigUint<Env::Api>>,
+    >(
+        self,
+        token_display_name: Arg0,
+        token_ticker: Arg1,
+        initial_supply: Arg2,
+    ) -> TxProxyCall<Env, From, To, Gas, ()> {
+        self.wrapped_tx
+            .raw_call()
+            .function_name("issueWrappedEgld")
+            .argument(&token_display_name)
+            .argument(&token_ticker)
+            .argument(&initial_supply)
+            .original_result()
+    }
+
+    pub fn wrapped_egld_token_identifier(
+        self,
+    ) -> TxProxyCall<Env, From, To, Gas, TokenIdentifier<Env::Api>> {
+        self.wrapped_tx
+            .raw_call()
+            .function_name("getWrappedEgldTokenIdentifier")
+            .original_result()
+    }
+}