Merge rc v3.3 with farm on behalf features

common/modules/original_owner_helper/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "original_owner_helper"
+version = "0.0.0"
+authors = ["MultiversX <[email protected]>"]
+edition = "2021"
+
+[lib]
+path = "src/lib.rs"
+
+[dependencies.multiversx-sc]
+version = "=0.53.2"
+features = ["esdt-token-payment-legacy-decode"]
+
+[dependencies.common_structs]
+path = "../../common_structs"

common/modules/original_owner_helper/src/lib.rs

@@ -0,0 +1,62 @@
+#![no_std]
+
+multiversx_sc::imports!();
+
+use common_structs::{FarmToken, PaymentsVec};
+
+#[multiversx_sc::module]
+pub trait OriginalOwnerHelperModule {
+    fn check_and_return_original_owner<T: FarmToken<Self::Api> + TopDecode>(
+        &self,
+        payments: &PaymentsVec<Self::Api>,
+        farm_token_mapper: &NonFungibleTokenMapper,
+    ) -> ManagedAddress {
+        let mut original_owner = ManagedAddress::zero();
+        for payment in payments.iter() {
+            let attributes: T = farm_token_mapper.get_token_attributes(payment.token_nonce);
+            let payment_original_owner = attributes.get_original_owner();
+
+            if original_owner.is_zero() {
+                original_owner = payment_original_owner;
+            } else {
+                require!(
+                    original_owner == payment_original_owner,
+                    "All position must have the same original owner"
+                );
+            }
+        }
+
+        require!(
+            !original_owner.is_zero(),
+            "Original owner could not be identified"
+        );
+
+        original_owner
+    }
+
+    fn check_additional_payments_original_owner<T: FarmToken<Self::Api> + TopDecode>(
+        &self,
+        user: &ManagedAddress,
+        payments: &PaymentsVec<Self::Api>,
+        farm_token_mapper: &NonFungibleTokenMapper,
+    ) {
+        if payments.len() == 1 {
+            return;
+        }
+
+        let farm_token_id = farm_token_mapper.get_token_id();
+        for payment in payments.into_iter() {
+            if payment.token_identifier != farm_token_id {
+                continue;
+            }
+
+            let attributes: T = farm_token_mapper.get_token_attributes(payment.token_nonce);
+            let payment_original_owner = attributes.get_original_owner();
+
+            require!(
+                user == &payment_original_owner,
+                "Provided address is not the same as the original owner"
+            );
+        }
+    }
+}

common/modules/permissions_hub_module/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "permissions_hub_module"
+version = "0.0.0"
+authors = ["MultiversX <[email protected]>"]
+edition = "2021"
+
+[lib]
+path = "src/permissions_hub_module.rs"
+
+[dependencies.permissions-hub]
+path = "../../../dex/permissions-hub"
+
+[dependencies.multiversx-sc]
+version = "=0.53.2"
+features = ["esdt-token-payment-legacy-decode"]

common/modules/permissions_hub_module/src/permissions_hub_module.rs

@@ -0,0 +1,32 @@
+#![no_std]
+
+multiversx_sc::imports!();
+multiversx_sc::derive_imports!();
+
+#[multiversx_sc::module]
+pub trait PermissionsHubModule {
+    fn require_user_whitelisted(&self, user: &ManagedAddress, authorized_address: &ManagedAddress) {
+        let permissions_hub_address = self.permissions_hub_address().get();
+        let is_whitelisted: bool = self
+            .permissions_hub_proxy(permissions_hub_address)
+            .is_whitelisted(user, authorized_address)
+            .execute_on_dest_context();
+
+        require!(is_whitelisted, "Caller is not whitelisted by the user");
+    }
+
+    #[only_owner]
+    #[endpoint(setPermissionsHubAddress)]
+    fn set_permissions_hub_address(&self, address: ManagedAddress) {
+        self.permissions_hub_address().set(&address);
+    }
+
+    #[proxy]
+    fn permissions_hub_proxy(
+        &self,
+        sc_address: ManagedAddress,
+    ) -> permissions_hub::Proxy<Self::Api>;
+
+    #[storage_mapper("permissionsHubAddress")]
+    fn permissions_hub_address(&self) -> SingleValueMapper<ManagedAddress>;
+}

dex/farm-with-locked-rewards/Cargo.toml

@@ -41,6 +41,12 @@ path = "../../common/modules/utils"
 [dependencies.permissions_module]
 path = "../../common/modules/permissions_module"
 
+[dependencies.permissions_hub_module]
+path = "../../common/modules/permissions_hub_module"
+
+[dependencies.original_owner_helper]
+path = "../../common/modules/original_owner_helper"
+
 [dependencies.sc_whitelist_module]
 path = "../../common/modules/sc_whitelist_module"
 

dex/farm-with-locked-rewards/src/external_interaction.rs

@@ -16,6 +16,8 @@ pub trait ExternalInteractionsModule:
     + farm_token::FarmTokenModule
     + pausable::PausableModule
     + permissions_module::PermissionsModule
+    + permissions_hub_module::PermissionsHubModule
+    + original_owner_helper::OriginalOwnerHelperModule
     + sc_whitelist_module::SCWhitelistModule
     + events::EventsModule
     + multiversx_sc_modules::default_issue_callbacks::DefaultIssueCallbacksModule
@@ -45,7 +47,13 @@ pub trait ExternalInteractionsModule:
         let caller = self.blockchain().get_caller();
         self.require_user_whitelisted(&user, &caller);
 
-        self.check_additional_payments_original_owner(&user);
+        let payments = self.get_non_empty_payments();
+        let farm_token_mapper = self.farm_token();
+        self.check_additional_payments_original_owner::<FarmTokenAttributes<Self::Api>>(
+            &user,
+            &payments,
+            &farm_token_mapper,
+        );
 
         let boosted_rewards = self.claim_only_boosted_payment(&user);
         let new_farm_token = self.enter_farm::<NoMintWrapper<Self>>(user.clone());
@@ -71,8 +79,13 @@ pub trait ExternalInteractionsModule:
     #[payable("*")]
     #[endpoint(claimRewardsOnBehalf)]
     fn claim_rewards_on_behalf(&self) -> ClaimRewardsResultType<Self::Api> {
-        let user = self.check_and_return_original_owner();
+        let payments = self.get_non_empty_payments();
+        let farm_token_mapper = self.farm_token();
         let caller = self.blockchain().get_caller();
+        let user = self.check_and_return_original_owner::<FarmTokenAttributes<Self::Api>>(
+            &payments,
+            &farm_token_mapper,
+        );
         self.require_user_whitelisted(&user, &caller);
 
         let claim_rewards_result = self.claim_rewards::<NoMintWrapper<Self>>(user.clone());
@@ -94,78 +107,4 @@ pub trait ExternalInteractionsModule:
 
         (claim_rewards_result.new_farm_token, locked_rewards_payment).into()
     }
-
-    fn check_and_return_original_owner(&self) -> ManagedAddress {
-        let payments = self.call_value().all_esdt_transfers().clone_value();
-        let farm_token_mapper = self.farm_token();
-        let mut original_owner = ManagedAddress::zero();
-        for payment in payments.into_iter() {
-            let attributes: FarmTokenAttributes<Self::Api> =
-                farm_token_mapper.get_token_attributes(payment.token_nonce);
-
-            if original_owner.is_zero() {
-                original_owner = attributes.original_owner;
-            } else {
-                require!(
-                    original_owner == attributes.original_owner,
-                    "All position must have the same original owner"
-                );
-            }
-        }
-
-        require!(
-            !original_owner.is_zero(),
-            "Original owner could not be identified"
-        );
-
-        original_owner
-    }
-
-    fn check_additional_payments_original_owner(&self, user: &ManagedAddress) {
-        let payments = self.call_value().all_esdt_transfers().clone_value();
-        if payments.len() == 1 {
-            return;
-        }
-
-        let farm_token_mapper = self.farm_token();
-        let farm_token_id = farm_token_mapper.get_token_id();
-        for payment in payments.into_iter() {
-            if payment.token_identifier != farm_token_id {
-                continue;
-            }
-
-            let attributes: FarmTokenAttributes<Self::Api> =
-                farm_token_mapper.get_token_attributes(payment.token_nonce);
-
-            require!(
-                user == &attributes.original_owner,
-                "Provided address is not the same as the original owner"
-            );
-        }
-    }
-
-    fn require_user_whitelisted(&self, user: &ManagedAddress, authorized_address: &ManagedAddress) {
-        let permissions_hub_address = self.permissions_hub_address().get();
-        let is_whitelisted: bool = self
-            .permissions_hub_proxy(permissions_hub_address)
-            .is_whitelisted(user, authorized_address)
-            .execute_on_dest_context();
-
-        require!(is_whitelisted, "Caller is not whitelisted by the user");
-    }
-
-    #[only_owner]
-    #[endpoint(setPermissionsHubAddress)]
-    fn set_permissions_hub_address(&self, address: ManagedAddress) {
-        self.permissions_hub_address().set(&address);
-    }
-
-    #[proxy]
-    fn permissions_hub_proxy(
-        &self,
-        sc_address: ManagedAddress,
-    ) -> permissions_hub::Proxy<Self::Api>;
-
-    #[storage_mapper("permissionsHubAddress")]
-    fn permissions_hub_address(&self) -> SingleValueMapper<ManagedAddress>;
 }

dex/farm-with-locked-rewards/src/lib.rs

@@ -26,6 +26,8 @@ pub trait Farm:
     + utils::UtilsModule
     + pausable::PausableModule
     + permissions_module::PermissionsModule
+    + permissions_hub_module::PermissionsHubModule
+    + original_owner_helper::OriginalOwnerHelperModule
     + sc_whitelist_module::SCWhitelistModule
     + events::EventsModule
     + multiversx_sc_modules::default_issue_callbacks::DefaultIssueCallbacksModule

dex/farm-with-locked-rewards/tests/farm_with_locked_rewards_setup/mod.rs

@@ -27,6 +27,7 @@ use locking_module::lock_with_energy_module::LockWithEnergyModule;
 use multiversx_sc_modules::pause::PauseModule;
 use pausable::{PausableModule, State};
 use permissions_hub::PermissionsHub;
+use permissions_hub_module::PermissionsHubModule;
 use rewards::RewardsModule;
 use sc_whitelist_module::SCWhitelistModule;
 use simple_lock::locked_token::LockedTokenModule;
@@ -601,7 +602,9 @@ where
                 &self.permissions_hub_wrapper,
                 &rust_biguint!(0),
                 |sc| {
-                    sc.whitelist(managed_address!(address_to_whitelist));
+                    let mut addresses = MultiValueEncoded::new();
+                    addresses.push(managed_address!(address_to_whitelist));
+                    sc.whitelist(addresses);
                 },
             )
             .assert_ok();