[MEX-580] Add on behalf features for farm SC

Cargo.toml

@@ -20,6 +20,8 @@ members = [
   "dex/proxy-deployer/meta",
   "dex/pair-mock",
   "dex/pair-mock/meta",
+  "dex/permissions-hub",
+  "dex/permissions-hub/meta",
 
   "energy-integration/energy-factory-mock",
   "energy-integration/energy-factory-mock/meta",

common/common_structs/src/farm_types.rs

@@ -80,6 +80,8 @@ pub trait FarmToken<M: ManagedTypeApi> {
     fn get_compounded_rewards(&self) -> BigUint<M>;
 
     fn get_initial_farming_tokens(&self) -> BigUint<M>;
+
+    fn get_original_owner(&self) -> ManagedAddress<M>;
 }
 
 impl<M: ManagedTypeApi> FarmToken<M> for FarmTokenAttributes<M> {
@@ -97,4 +99,9 @@ impl<M: ManagedTypeApi> FarmToken<M> for FarmTokenAttributes<M> {
     fn get_initial_farming_tokens(&self) -> BigUint<M> {
         &self.current_farm_amount - &self.compounded_reward
     }
+
+    #[inline]
+    fn get_original_owner(&self) -> ManagedAddress<M> {
+        self.original_owner.clone()
+    }
 }

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"
 
@@ -74,6 +80,9 @@ path = "../../locked-asset/energy-factory"
 [dependencies.energy-query]
 path = "../../energy-integration/common-modules/energy-query"
 
+[dependencies.permissions-hub]
+path = "../permissions-hub"
+
 [dependencies.multiversx-sc]
 version = "=0.53.2"
 features = ["esdt-token-payment-legacy-decode"]

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

@@ -0,0 +1,110 @@
+multiversx_sc::imports!();
+
+use common_structs::FarmTokenAttributes;
+use farm::{
+    base_functions::{self, ClaimRewardsResultType},
+    exit_penalty, EnterFarmResultType,
+};
+
+use crate::NoMintWrapper;
+
+#[multiversx_sc::module]
+pub trait ExternalInteractionsModule:
+    rewards::RewardsModule
+    + config::ConfigModule
+    + token_send::TokenSendModule
+    + 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
+    + base_functions::BaseFunctionsModule
+    + exit_penalty::ExitPenaltyModule
+    + locking_module::lock_with_energy_module::LockWithEnergyModule
+    + farm_base_impl::base_farm_init::BaseFarmInitModule
+    + farm_base_impl::base_farm_validation::BaseFarmValidationModule
+    + farm_base_impl::enter_farm::BaseEnterFarmModule
+    + farm_base_impl::claim_rewards::BaseClaimRewardsModule
+    + farm_base_impl::compound_rewards::BaseCompoundRewardsModule
+    + farm_base_impl::exit_farm::BaseExitFarmModule
+    + farm_boosted_yields::FarmBoostedYieldsModule
+    + farm_boosted_yields::boosted_yields_factors::BoostedYieldsFactorsModule
+    + week_timekeeping::WeekTimekeepingModule
+    + weekly_rewards_splitting::WeeklyRewardsSplittingModule
+    + weekly_rewards_splitting::events::WeeklyRewardsSplittingEventsModule
+    + weekly_rewards_splitting::global_info::WeeklyRewardsGlobalInfo
+    + weekly_rewards_splitting::locked_token_buckets::WeeklyRewardsLockedTokenBucketsModule
+    + weekly_rewards_splitting::update_claim_progress_energy::UpdateClaimProgressEnergyModule
+    + energy_query::EnergyQueryModule
+    + utils::UtilsModule
+{
+    #[payable("*")]
+    #[endpoint(enterFarmOnBehalf)]
+    fn enter_farm_on_behalf(&self, user: ManagedAddress) -> EnterFarmResultType<Self::Api> {
+        let caller = self.blockchain().get_caller();
+        self.require_user_whitelisted(&user, &caller);
+
+        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());
+        self.send_payment_non_zero(&caller, &new_farm_token);
+
+        let locked_rewards_payment = if boosted_rewards == 0 {
+            let locked_token_id = self.get_locked_token_id();
+            EsdtTokenPayment::new(locked_token_id, 0, boosted_rewards)
+        } else {
+            self.lock_virtual(
+                self.reward_token_id().get(),
+                boosted_rewards,
+                user.clone(),
+                user.clone(),
+            )
+        };
+
+        self.update_energy_and_progress(&user);
+
+        (new_farm_token, locked_rewards_payment).into()
+    }
+
+    #[payable("*")]
+    #[endpoint(claimRewardsOnBehalf)]
+    fn claim_rewards_on_behalf(&self) -> ClaimRewardsResultType<Self::Api> {
+        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());
+
+        self.send_payment_non_zero(&caller, &claim_rewards_result.new_farm_token);
+
+        let rewards_payment = claim_rewards_result.rewards;
+        let locked_rewards_payment = if rewards_payment.amount == 0 {
+            let locked_token_id = self.get_locked_token_id();
+            EsdtTokenPayment::new(locked_token_id, 0, rewards_payment.amount)
+        } else {
+            self.lock_virtual(
+                rewards_payment.token_identifier,
+                rewards_payment.amount,
+                user.clone(),
+                user,
+            )
+        };
+
+        (claim_rewards_result.new_farm_token, locked_rewards_payment).into()
+    }
+}