diff --git a/framework/scenario/tests/contract_without_macros.rs b/framework/scenario/tests/contract_without_macros.rs
index 91ca8b2eba..1121e88fdd 100644
--- a/framework/scenario/tests/contract_without_macros.rs
+++ b/framework/scenario/tests/contract_without_macros.rs
@@ -7,7 +7,6 @@
 // and maintenance.
 
 #![allow(unused)]
-#![allow(deprecated)] // TODO: unified syntax
 
 use multiversx_sc::{
     contract_base::ProxyObjNew,
@@ -103,11 +102,116 @@ mod module_1 {
     }
 
     pub trait ProxyTrait: multiversx_sc::contract_base::ProxyObjBase + Sized {
+        #[allow(clippy::too_many_arguments)]
+        #[allow(clippy::type_complexity)]
         fn version(
             &mut self,
-        ) -> multiversx_sc::types::ContractCallNoPayment<Self::Api, BigInt<Self::Api>> {
-            let ___address___ = self.extract_address();
-            multiversx_sc::types::ContractCallNoPayment::new(___address___, "version")
+        ) -> multiversx_sc::types::Tx<
+            multiversx_sc::types::TxScEnv<Self::Api>,
+            (),
+            Self::To,
+            (),
+            (),
+            multiversx_sc::types::FunctionCall<Self::Api>,
+            multiversx_sc::types::OriginalResultMarker<BigInt<Self::Api>>,
+        > {
+            multiversx_sc::types::TxBaseWithEnv::new_tx_from_sc()
+                .to(self.extract_proxy_to())
+                .original_result()
+                .raw_call("version")
+        }
+    }
+}
+
+mod sampler_adder_proxy {
+    #![allow(dead_code)]
+    #![allow(clippy::all)]
+    use multiversx_sc::proxy_imports::*;
+    pub struct AdderProxy;
+    impl<Env, From, To, Gas> TxProxyTrait<Env, From, To, Gas> for AdderProxy
+    where
+        Env: TxEnv,
+        From: TxFrom<Env>,
+        To: TxTo<Env>,
+        Gas: TxGas<Env>,
+    {
+        type TxProxyMethods = AdderProxyMethods<Env, From, To, Gas>;
+        fn proxy_methods(self, tx: Tx<Env, From, To, (), Gas, (), ()>) -> Self::TxProxyMethods {
+            AdderProxyMethods { wrapped_tx: tx }
+        }
+    }
+    pub struct AdderProxyMethods<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> AdderProxyMethods<Env, From, (), Gas>
+    where
+        Env: TxEnv,
+        Env::Api: VMApi,
+        From: TxFrom<Env>,
+        Gas: TxGas<Env>,
+    {
+        pub fn init<Arg0: ProxyArg<BigUint<Env::Api>>>(
+            self,
+            initial_value: Arg0,
+        ) -> TxTypedDeploy<Env, From, NotPayable, Gas, ()> {
+            self.wrapped_tx
+                .payment(NotPayable)
+                .raw_deploy()
+                .argument(&initial_value)
+                .original_result()
+        }
+    }
+    #[rustfmt::skip]
+    impl<Env, From, To, Gas> AdderProxyMethods<Env, From, To, Gas>
+    where
+        Env: TxEnv,
+        Env::Api: VMApi,
+        From: TxFrom<Env>,
+        To: TxTo<Env>,
+        Gas: TxGas<Env>,
+    {
+        pub fn upgrade<Arg0: ProxyArg<BigUint<Env::Api>>>(
+            self,
+            initial_value: Arg0,
+        ) -> TxTypedUpgrade<Env, From, To, NotPayable, Gas, ()> {
+            self.wrapped_tx
+                .payment(NotPayable)
+                .raw_upgrade()
+                .argument(&initial_value)
+                .original_result()
+        }
+    }
+    #[rustfmt::skip]
+    impl<Env, From, To, Gas> AdderProxyMethods<Env, From, To, Gas>
+    where
+        Env: TxEnv,
+        Env::Api: VMApi,
+        From: TxFrom<Env>,
+        To: TxTo<Env>,
+        Gas: TxGas<Env>,
+    {
+        pub fn sum(
+            self,
+        ) -> TxTypedCall<Env, From, To, NotPayable, Gas, BigUint<Env::Api>> {
+            self.wrapped_tx.payment(NotPayable).raw_call("getSum").original_result()
+        }
+        /// Add desired amount to the storage variable.
+        pub fn add<Arg0: ProxyArg<BigUint<Env::Api>>>(
+            self,
+            value: Arg0,
+        ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
+            self.wrapped_tx
+                .payment(NotPayable)
+                .raw_call("add")
+                .argument(&value)
+                .original_result()
         }
     }
 }
@@ -121,21 +225,25 @@ mod sample_adder {
     pub trait Adder:
         super::module_1::VersionModule + multiversx_sc::contract_base::ContractBase + Sized
     {
-        fn init(&self, initial_value: &BigInt<Self::Api>) {
-            self.set_sum(initial_value);
-        }
-        fn add(&self, value: BigInt<Self::Api>) {
-            let mut sum = self.get_sum();
-            sum.add_assign(value);
-            self.set_sum(&sum);
-        }
-        fn get_sum(&self) -> BigInt<Self::Api>;
-        fn set_sum(&self, sum: &BigInt<Self::Api>);
-        fn add_version(&self) {
-            self.add(self.version())
-        }
-        fn callback(&self);
-        fn callbacks(&self) -> self::CallbackProxyObj<Self::Api>;
+        #[allow(clippy::too_many_arguments)]
+        #[allow(clippy::type_complexity)]
+        fn init(&self, initial_value: multiversx_sc::types::BigUint<Self::Api>) {
+            self.sum().set(initial_value);
+        }
+        #[allow(clippy::too_many_arguments)]
+        #[allow(clippy::type_complexity)]
+        fn upgrade(&self, initial_value: multiversx_sc::types::BigUint<Self::Api>) {
+            self.init(initial_value);
+        }
+        /// Add desired amount to the storage variable.
+        #[allow(clippy::too_many_arguments)]
+        #[allow(clippy::type_complexity)]
+        fn add(&self, value: multiversx_sc::types::BigUint<Self::Api>) {
+            self.sum().update(|sum| *sum += value);
+        }
+        #[allow(clippy::too_many_arguments)]
+        #[allow(clippy::type_complexity)]
+        fn sum(&self) -> SingleValueMapper<Self::Api, multiversx_sc::types::BigUint<Self::Api>>;
     }
 
     /////////////////////////////////////////////////////////////////////////////////////////////////
@@ -149,17 +257,14 @@ mod sample_adder {
     where
         C: AutoImpl + super::module_1::AutoImpl,
     {
-        fn get_sum(&self) -> BigInt<Self::Api> {
-            let mut ___key___ = multiversx_sc::storage::StorageKey::<Self::Api>::new(&b"sum"[..]);
-            multiversx_sc::storage_get(multiversx_sc::types::ManagedRef::new(&___key___))
-        }
-        fn set_sum(&self, sum: &BigInt<Self::Api>) {
+        #[allow(clippy::too_many_arguments)]
+        #[allow(clippy::type_complexity)]
+        fn sum(&self) -> SingleValueMapper<Self::Api, multiversx_sc::types::BigUint<Self::Api>> {
             let mut ___key___ = multiversx_sc::storage::StorageKey::<Self::Api>::new(&b"sum"[..]);
-            multiversx_sc::storage_set(multiversx_sc::types::ManagedRef::new(&___key___), &sum);
-        }
-        fn callback(&self) {}
-        fn callbacks(&self) -> self::CallbackProxyObj<Self::Api> {
-            <self::CallbackProxyObj::<Self::Api> as multiversx_sc::contract_base::CallbackProxyObjBase>::new_cb_proxy_obj()
+            <SingleValueMapper<
+            Self::Api,
+            multiversx_sc::types::BigUint<Self::Api>,
+        > as multiversx_sc::storage::mappers::StorageMapper<Self::Api>>::new(___key___)
         }
     }
 
@@ -172,11 +277,11 @@ mod sample_adder {
         Adder + multiversx_sc::contract_base::ContractBase + super::module_1::EndpointWrappers
     {
         #[inline]
-        fn call_get_sum(&self) {
+        fn call_sum(&self) {
             <Self::Api as multiversx_sc::api::VMApi>::init_static();
             multiversx_sc::io::call_value_init::not_payable::<Self::Api>();
             let () = multiversx_sc::io::load_endpoint_args::<Self::Api, ()>(());
-            let result = self.get_sum();
+            let result = self.sum();
             multiversx_sc::io::finish_multi::<Self::Api, _>(&result);
         }
         #[inline]
@@ -185,9 +290,19 @@ mod sample_adder {
             multiversx_sc::io::call_value_init::not_payable::<Self::Api>();
             let (initial_value, ()) = multiversx_sc::io::load_endpoint_args::<
                 Self::Api,
-                (multiversx_sc::types::BigInt<Self::Api>, ()),
+                (multiversx_sc::types::BigUint<Self::Api>, ()),
             >(("initial_value", ()));
-            self.init(&initial_value);
+            self.init(initial_value);
+        }
+        #[inline]
+        fn call_upgrade(&self) {
+            <Self::Api as multiversx_sc::api::VMApi>::init_static();
+            multiversx_sc::io::call_value_init::not_payable::<Self::Api>();
+            let (initial_value, ()) = multiversx_sc::io::load_endpoint_args::<
+                Self::Api,
+                (multiversx_sc::types::BigUint<Self::Api>, ()),
+            >(("initial_value", ()));
+            self.upgrade(initial_value);
         }
         #[inline]
         fn call_add(&self) {
@@ -195,38 +310,55 @@ mod sample_adder {
             multiversx_sc::io::call_value_init::not_payable::<Self::Api>();
             let (value, ()) = multiversx_sc::io::load_endpoint_args::<
                 Self::Api,
-                (multiversx_sc::types::BigInt<Self::Api>, ()),
+                (multiversx_sc::types::BigUint<Self::Api>, ()),
             >(("value", ()));
             self.add(value);
         }
-
         fn call(&self, fn_name: &str) -> bool {
             if match fn_name {
                 "callBack" => {
-                    Adder::callback(self);
+                    self::EndpointWrappers::callback(self);
+                    return true;
+                },
+                "init"
+                    if <Self::Api as multiversx_sc::api::VMApi>::external_view_init_override() =>
+                {
+                    multiversx_sc::external_view_contract::external_view_contract_constructor::<
+                        Self::Api,
+                    >();
                     return true;
                 },
                 "getSum" => {
-                    self.call_get_sum();
+                    self.call_sum();
                     true
                 },
-                "init" => {
+                "init"
+                    if !<Self::Api as multiversx_sc::api::VMApi>::external_view_init_override() =>
+                {
                     self.call_init();
                     true
                 },
+                "upgrade" => {
+                    self.call_upgrade();
+                    true
+                },
                 "add" => {
                     self.call_add();
                     true
                 },
-                _other => false,
+                other => false,
             } {
                 return true;
             }
-            if super::module_1::EndpointWrappers::call(self, fn_name) {
-                return true;
-            }
             false
         }
+        fn callback_selector(
+            &self,
+            mut ___cb_closure___: multiversx_sc::types::CallbackClosureForDeser<Self::Api>,
+        ) -> multiversx_sc::types::CallbackSelectorResult<Self::Api> {
+            multiversx_sc::types::CallbackSelectorResult::NotProcessed(___cb_closure___)
+        }
+        fn callback(&self) {}
     }
 
     impl<A> EndpointWrappers for multiversx_sc::contract_base::UniversalContractObj<A> where
@@ -234,24 +366,224 @@ mod sample_adder {
     {
     }
 
+    pub struct AbiProvider {}
+    impl multiversx_sc::contract_base::ContractAbiProvider for AbiProvider {
+        type Api = multiversx_sc::api::uncallable::UncallableApi;
+        fn abi() -> multiversx_sc::abi::ContractAbi {
+            let mut contract_abi = multiversx_sc::abi::ContractAbi::new(
+                multiversx_sc::abi::BuildInfoAbi {
+                    contract_crate: multiversx_sc::abi::ContractCrateBuildAbi {
+                        name: "adder",
+                        version: "0.0.0",
+                        git_version: "",
+                    },
+                    framework: multiversx_sc::abi::FrameworkBuildAbi::create(),
+                },
+                &[
+                    "One of the simplest smart contracts possible,",
+                    "it holds a single variable in storage, which anyone can increment.",
+                ],
+                "Adder",
+                false,
+            );
+            let mut endpoint_abi = multiversx_sc::abi::EndpointAbi::new(
+                &[],
+                "getSum",
+                "sum",
+                false,
+                false,
+                multiversx_sc::abi::EndpointMutabilityAbi::Readonly,
+                multiversx_sc::abi::EndpointTypeAbi::Endpoint,
+                &[],
+                &[],
+                false,
+            );
+            endpoint_abi
+            .add_output::<
+                SingleValueMapper<Self::Api, multiversx_sc::types::BigUint<Self::Api>>,
+            >(&[]);
+            contract_abi
+            .add_type_descriptions::<
+                SingleValueMapper<Self::Api, multiversx_sc::types::BigUint<Self::Api>>,
+            >();
+            contract_abi.endpoints.push(endpoint_abi);
+            let mut endpoint_abi = multiversx_sc::abi::EndpointAbi::new(
+                &[],
+                "init",
+                "init",
+                false,
+                false,
+                multiversx_sc::abi::EndpointMutabilityAbi::Mutable,
+                multiversx_sc::abi::EndpointTypeAbi::Init,
+                &[],
+                &[],
+                false,
+            );
+            endpoint_abi.add_input::<multiversx_sc::types::BigUint<Self::Api>>("initial_value");
+            contract_abi.add_type_descriptions::<multiversx_sc::types::BigUint<Self::Api>>();
+            contract_abi.constructors.push(endpoint_abi);
+            let mut endpoint_abi = multiversx_sc::abi::EndpointAbi::new(
+                &[],
+                "upgrade",
+                "upgrade",
+                false,
+                false,
+                multiversx_sc::abi::EndpointMutabilityAbi::Mutable,
+                multiversx_sc::abi::EndpointTypeAbi::Upgrade,
+                &[],
+                &[],
+                false,
+            );
+            endpoint_abi.add_input::<multiversx_sc::types::BigUint<Self::Api>>("initial_value");
+            contract_abi.add_type_descriptions::<multiversx_sc::types::BigUint<Self::Api>>();
+            contract_abi.upgrade_constructors.push(endpoint_abi);
+            let mut endpoint_abi = multiversx_sc::abi::EndpointAbi::new(
+                &["Add desired amount to the storage variable."],
+                "add",
+                "add",
+                false,
+                false,
+                multiversx_sc::abi::EndpointMutabilityAbi::Mutable,
+                multiversx_sc::abi::EndpointTypeAbi::Endpoint,
+                &[],
+                &[],
+                false,
+            );
+            endpoint_abi.add_input::<multiversx_sc::types::BigUint<Self::Api>>("value");
+            contract_abi.add_type_descriptions::<multiversx_sc::types::BigUint<Self::Api>>();
+            contract_abi.endpoints.push(endpoint_abi);
+            contract_abi
+        }
+    }
+
+    #[allow(non_snake_case)]
+    pub mod endpoints {
+        use super::EndpointWrappers;
+        pub fn sum<A>()
+        where
+            A: multiversx_sc::api::VMApi,
+        {
+            super::EndpointWrappers::call_sum(
+                &multiversx_sc::contract_base::UniversalContractObj::<A>::new(),
+            );
+        }
+        pub fn init<A>()
+        where
+            A: multiversx_sc::api::VMApi,
+        {
+            super::EndpointWrappers::call_init(
+                &multiversx_sc::contract_base::UniversalContractObj::<A>::new(),
+            );
+        }
+        pub fn upgrade<A>()
+        where
+            A: multiversx_sc::api::VMApi,
+        {
+            super::EndpointWrappers::call_upgrade(
+                &multiversx_sc::contract_base::UniversalContractObj::<A>::new(),
+            );
+        }
+        pub fn add<A>()
+        where
+            A: multiversx_sc::api::VMApi,
+        {
+            super::EndpointWrappers::call_add(
+                &multiversx_sc::contract_base::UniversalContractObj::<A>::new(),
+            );
+        }
+        pub fn callBack<A>()
+        where
+            A: multiversx_sc::api::VMApi,
+        {
+            super::EndpointWrappers::callback(
+                &multiversx_sc::contract_base::UniversalContractObj::<A>::new(),
+            );
+        }
+    }
     pub trait ProxyTrait:
         multiversx_sc::contract_base::ProxyObjBase + super::module_1::ProxyTrait
     {
-        fn get_sum(
+        #[allow(clippy::too_many_arguments)]
+        #[allow(clippy::type_complexity)]
+        fn sum(
             &mut self,
-        ) -> multiversx_sc::types::ContractCallNoPayment<Self::Api, BigInt<Self::Api>> {
-            let ___address___ = self.extract_address();
-            multiversx_sc::types::ContractCallNoPayment::new(___address___, "get_sum")
-        }
-        fn add(
+        ) -> multiversx_sc::types::Tx<
+            multiversx_sc::types::TxScEnv<Self::Api>,
+            (),
+            Self::To,
+            (),
+            (),
+            multiversx_sc::types::FunctionCall<Self::Api>,
+            multiversx_sc::types::OriginalResultMarker<
+                SingleValueMapper<Self::Api, multiversx_sc::types::BigUint<Self::Api>>,
+            >,
+        > {
+            multiversx_sc::types::TxBaseWithEnv::new_tx_from_sc()
+                .to(self.extract_proxy_to())
+                .original_result()
+                .raw_call("getSum")
+        }
+        #[allow(clippy::too_many_arguments)]
+        #[allow(clippy::type_complexity)]
+        fn init<Arg0: multiversx_sc::types::ProxyArg<multiversx_sc::types::BigUint<Self::Api>>>(
             &mut self,
-            amount: &BigInt<Self::Api>,
-        ) -> multiversx_sc::types::ContractCallNoPayment<Self::Api, ()> {
-            let ___address___ = self.extract_address();
-            let mut ___contract_call___ =
-                multiversx_sc::types::ContractCallNoPayment::new(___address___, "add");
-            multiversx_sc::types::ContractCall::proxy_arg(&mut ___contract_call___, amount);
-            ___contract_call___
+            initial_value: Arg0,
+        ) -> multiversx_sc::types::Tx<
+            multiversx_sc::types::TxScEnv<Self::Api>,
+            (),
+            Self::To,
+            (),
+            (),
+            multiversx_sc::types::DeployCall<multiversx_sc::types::TxScEnv<Self::Api>, ()>,
+            multiversx_sc::types::OriginalResultMarker<()>,
+        > {
+            multiversx_sc::types::TxBaseWithEnv::new_tx_from_sc()
+                .raw_deploy()
+                .argument(&initial_value)
+                .original_result()
+                .to(self.extract_proxy_to())
+        }
+        #[allow(clippy::too_many_arguments)]
+        #[allow(clippy::type_complexity)]
+        fn upgrade<
+            Arg0: multiversx_sc::types::ProxyArg<multiversx_sc::types::BigUint<Self::Api>>,
+        >(
+            &mut self,
+            initial_value: Arg0,
+        ) -> multiversx_sc::types::Tx<
+            multiversx_sc::types::TxScEnv<Self::Api>,
+            (),
+            Self::To,
+            (),
+            (),
+            multiversx_sc::types::FunctionCall<Self::Api>,
+            multiversx_sc::types::OriginalResultMarker<()>,
+        > {
+            multiversx_sc::types::TxBaseWithEnv::new_tx_from_sc()
+                .to(self.extract_proxy_to())
+                .original_result()
+                .raw_call("upgrade")
+                .argument(&initial_value)
+        }
+        #[allow(clippy::too_many_arguments)]
+        #[allow(clippy::type_complexity)]
+        fn add<Arg0: multiversx_sc::types::ProxyArg<multiversx_sc::types::BigUint<Self::Api>>>(
+            &mut self,
+            value: Arg0,
+        ) -> multiversx_sc::types::Tx<
+            multiversx_sc::types::TxScEnv<Self::Api>,
+            (),
+            Self::To,
+            (),
+            (),
+            multiversx_sc::types::FunctionCall<Self::Api>,
+            multiversx_sc::types::OriginalResultMarker<()>,
+        > {
+            multiversx_sc::types::TxBaseWithEnv::new_tx_from_sc()
+                .to(self.extract_proxy_to())
+                .original_result()
+                .raw_call("add")
+                .argument(&value)
         }
     }
 
@@ -288,17 +620,21 @@ mod sample_adder {
         A: multiversx_sc::api::VMApi,
     {
         fn call(&self, fn_name: &str) -> bool {
-            EndpointWrappers::call(
-                &multiversx_sc::contract_base::UniversalContractObj::<A>::new(),
-                fn_name,
-            )
+            EndpointWrappers::call(self, fn_name)
         }
     }
 
+    pub fn contract_obj<A>() -> ContractObj<A>
+    where
+        A: multiversx_sc::api::VMApi,
+    {
+        ContractObj {
+            _phantom: core::marker::PhantomData,
+        }
+    }
     pub struct ContractBuilder;
-
-    impl multiversx_sc::contract_base::CallableContractBuilder for ContractBuilder {
-        fn new_contract_obj<A: multiversx_sc::api::VMApi>(
+    impl multiversx_sc::contract_base::CallableContractBuilder for self::ContractBuilder {
+        fn new_contract_obj<A: multiversx_sc::api::VMApi + Send + Sync>(
             &self,
         ) -> multiversx_sc::types::heap::Box<dyn multiversx_sc::contract_base::CallableContract>
         {
@@ -308,25 +644,6 @@ mod sample_adder {
         }
     }
 
-    pub struct AbiProvider {}
-
-    impl multiversx_sc::contract_base::ContractAbiProvider for AbiProvider {
-        type Api = multiversx_sc::api::uncallable::UncallableApi;
-
-        fn abi() -> multiversx_sc::abi::ContractAbi {
-            multiversx_sc::abi::ContractAbi::default()
-        }
-    }
-
-    pub fn contract_obj<A>() -> ContractObj<A>
-    where
-        A: multiversx_sc::api::VMApi,
-    {
-        ContractObj {
-            _phantom: core::marker::PhantomData,
-        }
-    }
-
     pub struct Proxy<A>
     where
         A: multiversx_sc::api::VMApi + 'static,
@@ -465,27 +782,24 @@ fn contract_without_macros_basic() {
 
     let adder = sample_adder::contract_obj::<SingleTxApi>();
 
-    adder.init(&BigInt::from(5));
-    assert_eq!(BigInt::from(5), adder.get_sum());
+    adder.init(multiversx_sc::types::BigUint::from(5u32));
+    assert_eq!(multiversx_sc::types::BigUint::from(5u32), adder.sum().get());
 
-    adder.add(BigInt::from(7));
-    assert_eq!(BigInt::from(12), adder.get_sum());
-
-    adder.add(BigInt::from(-1));
-    assert_eq!(BigInt::from(11), adder.get_sum());
+    adder.add(multiversx_sc::types::BigUint::from(7u32));
+    assert_eq!(
+        multiversx_sc::types::BigUint::from(12u32),
+        adder.sum().get()
+    );
 
     assert_eq!(BigInt::from(100), adder.version());
 
-    adder.add_version();
-    assert_eq!(BigInt::from(111), adder.get_sum());
-
     assert!(!adder.call("invalid_endpoint"));
 
-    assert!(adder.call("version"));
+    assert!(adder.call("getSum"));
 
     let mut own_proxy =
         sample_adder::Proxy::<StaticApi>::new_proxy_obj().contract(ManagedAddress::zero());
-    let _ = own_proxy.get_sum();
+    let _ = own_proxy.sum();
 
     let _ = multiversx_sc_meta_lib::abi_json::contract_abi::<sample_adder::AbiProvider>();
 }