merge with new base

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",

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

@@ -74,6 +74,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,171 @@
+multiversx_sc::imports!();
+
+use common_structs::FarmTokenAttributes;
+use farm::{
+    base_functions::{self, ClaimRewardsResultType},
+    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
+    + sc_whitelist_module::SCWhitelistModule
+    + events::EventsModule
+    + multiversx_sc_modules::default_issue_callbacks::DefaultIssueCallbacksModule
+    + base_functions::BaseFunctionsModule
+    + 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
+    + farm_boosted_yields::custom_reward_logic::CustomRewardLogicModule
+    + 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);
+
+        self.check_additional_payments_original_owner(&user);
+
+        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 user = self.check_and_return_original_owner();
+        let caller = self.blockchain().get_caller();
+        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()
+    }
+
+    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

@@ -3,6 +3,8 @@
 multiversx_sc::imports!();
 multiversx_sc::derive_imports!();
 
+pub mod external_interaction;
+
 use common_structs::FarmTokenAttributes;
 use contexts::storage_cache::StorageCache;
 use core::marker::PhantomData;
@@ -28,6 +30,7 @@ pub trait Farm:
     + events::EventsModule
     + multiversx_sc_modules::default_issue_callbacks::DefaultIssueCallbacksModule
     + farm::base_functions::BaseFunctionsModule
+    + external_interaction::ExternalInteractionsModule
     + farm_base_impl::base_farm_init::BaseFarmInitModule
     + farm_base_impl::base_farm_validation::BaseFarmValidationModule
     + farm_base_impl::enter_farm::BaseEnterFarmModule