new unit test & code updates

farm-boosted-rewards-subscriber/src/service.rs

@@ -41,12 +41,10 @@ pub trait ServiceModule:
             "Invalid service index"
         );
         let is_premium_service = service_index == SubscriptionUserType::Premium as usize;
-
         let energy_threshold = self.energy_threshold().get();
-
         let fees_contract_address = self.fees_contract_address().get();
-
         let mut processed_user_ids = ManagedVec::new();
+
         for user_id in user_ids {
             if is_premium_service {
                 let opt_user_address = self
@@ -141,8 +139,17 @@ pub trait ServiceModule:
         let lock_period = self.lock_period().get();
 
         // Call lock for each user to properly update their energy
-        for mex_operation in mex_operations_list.into_iter() {
-            let user_amount = &total_tokens_to_lock.amount * &mex_operation.amount / &total_fees;
+        let mut total_processed_amount = BigUint::zero();
+        for i in 0..mex_operations_list.len() {
+            let mex_operation = mex_operations_list.get(i);
+            let user_amount = if i < mex_operations_list.len() - 1 {
+                let amount = &total_tokens_to_lock.amount * &mex_operation.amount / &total_fees;
+                total_processed_amount += &amount;
+                amount
+            } else {
+                &total_tokens_to_lock.amount - &total_processed_amount
+            };
+
             if user_amount > 0 {
                 self.call_lock_tokens(
                     simple_lock_address.clone(),

farm-boosted-rewards-subscriber/tests/farm_setup/mod.rs

@@ -6,6 +6,7 @@ use std::rc::Rc;
 use multiversx_sc::codec::multi_types::OptionalValue;
 use multiversx_sc::storage::mappers::StorageTokenWrapper;
 use multiversx_sc::types::{Address, BigInt, EsdtLocalRole, ManagedAddress, MultiValueEncoded};
+use multiversx_sc_modules::pause::PauseModule;
 use multiversx_sc_scenario::testing_framework::TxResult;
 use multiversx_sc_scenario::{
     managed_address, managed_biguint, managed_token_id, rust_biguint,
@@ -101,6 +102,7 @@ where
 
                 sc.locked_token()
                     .set_token_id(managed_token_id!(locked_token_id));
+                sc.unpause_endpoint();
             })
             .assert_ok();
 
@@ -171,6 +173,12 @@ where
             &locked_reward_token_roles[..],
         );
 
+        b_mock.borrow_mut().set_esdt_local_roles(
+            energy_factory_wrapper.address_ref(),
+            reward_token_id,
+            &farming_token_roles[..],
+        );
+
         b_mock
             .borrow_mut()
             .execute_tx(owner, &energy_factory_wrapper, &rust_zero, |sc| {

farm-boosted-rewards-subscriber/tests/subscriber_setup/mod.rs

@@ -11,7 +11,7 @@ use farm_boosted_rewards_subscriber::{
 use multiversx_sc::{
     codec::multi_types::MultiValue2,
     storage::mappers::AddressId,
-    types::{Address, ManagedVec, MultiValueEncoded},
+    types::{Address, EsdtLocalRole, ManagedVec, MultiValueEncoded},
 };
 use multiversx_sc_scenario::{
     managed_address, managed_biguint, managed_token_id, rust_biguint,
@@ -88,6 +88,13 @@ where
             })
             .assert_ok();
 
+        let mex_token_roles = [EsdtLocalRole::Burn];
+        b_mock.borrow_mut().set_esdt_local_roles(
+            sub_wrapper.address_ref(),
+            reward_token_id,
+            &mex_token_roles[..],
+        );
+
         Self {
             b_mock,
             owner_addr: owner_addr.clone(),
@@ -185,4 +192,36 @@ where
             },
         )
     }
+
+    pub fn call_perform_mex_operation(
+        &mut self,
+        service_index: usize,
+        users_list: Vec<AddressId>,
+    ) -> TxResult {
+        self.b_mock.borrow_mut().execute_tx(
+            &self.owner_addr,
+            &self.sub_wrapper,
+            &rust_biguint!(0),
+            |sc| {
+                let mut user_ids = MultiValueEncoded::new();
+                for user_id in users_list {
+                    user_ids.push(user_id);
+                }
+
+                sc.perform_mex_operations_endpoint(service_index, managed_biguint!(1u64), user_ids);
+            },
+        )
+    }
+
+    pub fn call_claim_fees(&mut self, expected_output_payments_no: usize) -> TxResult {
+        self.b_mock.borrow_mut().execute_tx(
+            &self.owner_addr,
+            &self.sub_wrapper,
+            &rust_biguint!(0),
+            |sc| {
+                let result = sc.claim_fees();
+                assert_eq!(result.len(), expected_output_payments_no);
+            },
+        )
+    }
 }

farm-boosted-rewards-subscriber/tests/subscriber_test.rs

@@ -630,3 +630,123 @@ fn claim_boosted_rewards_for_premium_user_test() {
         &rust_biguint!(500),
     );
 }
+
+#[test]
+fn mex_operation_with_claim_fees_test() {
+    let (
+        b_mock_rc,
+        _mex_pair_setup,
+        _stable_pair_setup,
+        _farm_setup,
+        mut subscription_setup,
+        mut subscriber_setup,
+    ) = init_all(
+        pair::contract_obj,
+        farm_with_locked_rewards::contract_obj,
+        energy_factory::contract_obj,
+        subscription_fee::contract_obj,
+        farm_boosted_rewards_subscriber::contract_obj,
+    );
+
+    let first_user = b_mock_rc
+        .borrow_mut()
+        .create_user_account(&rust_biguint!(0));
+    let second_user = b_mock_rc
+        .borrow_mut()
+        .create_user_account(&rust_biguint!(0));
+    let first_user_id = 1;
+    let second_user_id = 2;
+
+    b_mock_rc.borrow_mut().set_block_epoch(2);
+
+    subscriber_setup
+        .call_register_service(vec![
+            (
+                Some(WEGLD_TOKEN_ID.to_vec()),
+                1_000,
+                WEEKLY_SUBSCRIPTION_EPOCHS,
+            ),
+            (
+                Some(WEGLD_TOKEN_ID.to_vec()),
+                500,
+                WEEKLY_SUBSCRIPTION_EPOCHS,
+            ),
+        ])
+        .assert_ok();
+
+    subscription_setup
+        .call_approve_service(subscriber_setup.sub_wrapper.address_ref())
+        .assert_ok();
+
+    b_mock_rc
+        .borrow_mut()
+        .set_esdt_balance(&first_user, WEGLD_TOKEN_ID, &rust_biguint!(1_000_000));
+
+    subscription_setup
+        .call_deposit(&first_user, WEGLD_TOKEN_ID, 1_000_000)
+        .assert_ok();
+
+    b_mock_rc.borrow_mut().set_esdt_balance(
+        &second_user,
+        WEGLD_TOKEN_ID,
+        &rust_biguint!(1_000_000),
+    );
+
+    subscription_setup
+        .call_deposit(&second_user, WEGLD_TOKEN_ID, 1_000_000)
+        .assert_ok();
+
+    // Subscribe to standard service
+    let standard_service = 0;
+    subscription_setup
+        .call_subscribe(&first_user, vec![(1, standard_service)])
+        .assert_ok();
+    subscription_setup
+        .call_subscribe(&second_user, vec![(1, standard_service)])
+        .assert_ok();
+
+    subscriber_setup
+        .call_subtract_payment(standard_service, vec![first_user_id, second_user_id])
+        .assert_ok();
+
+    subscriber_setup
+        .call_perform_mex_operation(standard_service, vec![first_user_id, second_user_id])
+        .assert_ok();
+
+    // Expected locked tokens balance: 1799
+    b_mock_rc
+        .borrow()
+        .check_nft_balance::<LockedTokenAttributes<DebugApi>>(
+            &first_user,
+            LOCKED_TOKEN_ID,
+            1,
+            &rust_biguint!(1799),
+            None,
+        );
+
+    // Expected locked tokens balance: 1800 - the last user is computed by difference
+    b_mock_rc
+        .borrow()
+        .check_nft_balance::<LockedTokenAttributes<DebugApi>>(
+            &second_user,
+            LOCKED_TOKEN_ID,
+            1,
+            &rust_biguint!(1800),
+            None,
+        );
+
+    b_mock_rc.borrow().check_esdt_balance(
+        &subscriber_setup.owner_addr,
+        WEGLD_TOKEN_ID,
+        &rust_biguint!(0),
+    );
+
+    let expected_fee_amount = 160;
+    subscriber_setup.call_claim_fees(1).assert_ok();
+
+    b_mock_rc.borrow().check_esdt_balance(
+        &subscriber_setup.owner_addr,
+        WEGLD_TOKEN_ID,
+        &rust_biguint!(expected_fee_amount),
+    );
+}