Destroy farm in proxy-dex

locked-asset/proxy_dex/src/proxy_farm.rs

@@ -234,6 +234,79 @@ pub trait ProxyFarmModule:
         (initial_proxy_farming_tokens, exit_result.reward_tokens).into()
     }
 
+    #[payable("*")]
+    #[endpoint(destroyFarmProxy)]
+    fn destroy_farm_proxy(
+        &self,
+        farm_address: ManagedAddress,
+        first_token_amount_min: BigUint,
+        second_token_amount_min: BigUint,
+        opt_original_caller: OptionalValue<ManagedAddress>,
+    ) -> MultiValueEncoded<EsdtTokenPayment> {
+        self.require_is_intermediated_farm(&farm_address);
+        self.require_wrapped_farm_token_id_not_empty();
+        self.require_wrapped_lp_token_id_not_empty();
+
+        let wrapped_farm_token_mapper = self.wrapped_farm_token();
+        let payment = self.call_value().single_esdt();
+        wrapped_farm_token_mapper.require_same_token(&payment.token_identifier);
+
+        let full_wrapped_farm_attributes: WrappedFarmTokenAttributes<Self::Api> = self
+            .blockchain()
+            .get_token_attributes(&payment.token_identifier, payment.token_nonce);
+
+        let wrapped_farm_attributes_for_exit: WrappedFarmTokenAttributes<Self::Api> =
+            full_wrapped_farm_attributes.into_part(&payment.amount);
+
+        let caller = self.blockchain().get_caller();
+        let original_caller = self.get_orig_caller_from_opt(&caller, opt_original_caller);
+
+        let exit_result = self.call_exit_farm(
+            original_caller.clone(),
+            farm_address.clone(),
+            wrapped_farm_attributes_for_exit.farm_token.clone(),
+        );
+
+        self.burn_if_base_asset(&exit_result.farming_tokens);
+
+        let wrapped_farm_tokens_for_initial_tokens = WrappedFarmToken {
+            payment: payment.clone(),
+            attributes: wrapped_farm_attributes_for_exit.clone(),
+        };
+
+        let initial_proxy_farming_tokens = self
+            .handle_farm_penalty_and_get_output_proxy_farming_token(
+                &original_caller,
+                wrapped_farm_tokens_for_initial_tokens,
+                exit_result.farming_tokens.amount,
+            );
+
+        let pair_address = self.lp_address_for_lp(&exit_result.farming_tokens.token_identifier).get();
+
+        let mut output_payments = self.remove_liquidity_proxy_common(
+            initial_proxy_farming_tokens.clone(),
+            pair_address,
+            first_token_amount_min,
+            second_token_amount_min,
+        );
+
+        // Push farm rewards
+        output_payments.push(exit_result.reward_tokens.clone());
+
+        self.send_multiple_tokens_if_not_zero(&caller, &output_payments);
+
+
+        self.emit_exit_farm_proxy_event(
+            &original_caller,
+            &farm_address,
+            payment,
+            wrapped_farm_attributes_for_exit,
+            exit_result.reward_tokens.clone(),
+        );
+
+        output_payments.into()
+    }
+
     fn handle_farm_penalty_and_get_output_proxy_farming_token(
         &self,
         caller: &ManagedAddress,

locked-asset/proxy_dex/src/proxy_pair.rs

@@ -68,6 +68,8 @@ pub trait ProxyPairModule:
             second_payment.amount.clone() - &add_liq_result.second_token_leftover.amount
         };
 
+        self.lp_address_for_lp(&add_liq_result.lp_tokens_received.token_identifier).set(pair_address.clone());
+
         let new_token_attributes = WrappedLpTokenAttributes {
             locked_tokens: locked_token_used,
             lp_token_id: add_liq_result.lp_tokens_received.token_identifier.clone(),
@@ -143,12 +145,32 @@ pub trait ProxyPairModule:
         self.require_wrapped_lp_token_id_not_empty();
 
         let payment = self.call_value().single_esdt();
+
+        let output_payments = self.remove_liquidity_proxy_common(
+            payment,
+            pair_address,
+            first_token_amount_min,
+            second_token_amount_min,
+        );
+        let caller = self.blockchain().get_caller();
+        self.send_multiple_tokens_if_not_zero(&caller, &output_payments);
+
+        output_payments.into()
+    }
+
+    fn remove_liquidity_proxy_common(
+        &self,
+        input_payment: EsdtTokenPayment,
+        pair_address: ManagedAddress,
+        first_token_amount_min: BigUint,
+        second_token_amount_min: BigUint,
+    ) -> ManagedVec<EsdtTokenPayment> {
         let wrapped_lp_mapper = self.wrapped_lp_token();
-        wrapped_lp_mapper.require_same_token(&payment.token_identifier);
+        wrapped_lp_mapper.require_same_token(&input_payment.token_identifier);
 
         let caller = self.blockchain().get_caller();
         let attributes: WrappedLpTokenAttributes<Self::Api> =
-            self.get_attributes_as_part_of_fixed_supply(&payment, &wrapped_lp_mapper);
+            self.get_attributes_as_part_of_fixed_supply(&input_payment, &wrapped_lp_mapper);
 
         let remove_liq_result = self.call_remove_liquidity(
             pair_address.clone(),
@@ -206,20 +228,18 @@ pub trait ProxyPairModule:
         let other_tokens = received_token_refs.other_token_ref.clone();
         output_payments.push(other_tokens);
 
-        wrapped_lp_mapper.nft_burn(payment.token_nonce, &payment.amount);
-
-        self.send_multiple_tokens_if_not_zero(&caller, &output_payments);
+        wrapped_lp_mapper.nft_burn(input_payment.token_nonce, &input_payment.amount);
 
         self.emit_remove_liquidity_proxy_event(
             &caller,
             &pair_address,
-            payment,
+            input_payment,
             attributes,
             remove_liq_result.first_token_received,
             remove_liq_result.second_token_received,
         );
 
-        output_payments.into()
+        output_payments
     }
 
     #[payable("*")]
@@ -278,4 +298,11 @@ pub trait ProxyPairModule:
     fn require_wrapped_lp_token_id_not_empty(&self) {
         require!(!self.wrapped_lp_token().is_empty(), "Empty token id");
     }
+
+    #[storage_mapper("lpAddressForLp")]
+    fn lp_address_for_lp(
+        &self,
+        lp: &TokenIdentifier,
+    ) -> SingleValueMapper<ManagedAddress>;
+
 }

locked-asset/proxy_dex/tests/proxy_farm_test.rs

@@ -1419,3 +1419,225 @@ fn increase_proxy_farm_proxy_lp_energy() {
         }),
     );
 }
+
+#[test]
+fn destroy_farm_locked_tokens_test() {
+    let mut setup = ProxySetup::new(
+        proxy_dex::contract_obj,
+        pair::contract_obj,
+        farm_with_locked_rewards::contract_obj,
+        energy_factory::contract_obj,
+    );
+
+    setup
+        .b_mock
+        .execute_tx(
+            &setup.owner,
+            &setup.farm_locked_wrapper,
+            &rust_biguint!(0),
+            |sc| {
+                sc.farming_token_id().set(&managed_token_id!(LP_TOKEN_ID));
+
+                // set produce rewards to false for easier calculation
+                sc.produce_rewards_enabled().set(false);
+            },
+        )
+        .assert_ok();
+
+    setup.b_mock.set_esdt_local_roles(
+        setup.farm_locked_wrapper.address_ref(),
+        LP_TOKEN_ID,
+        &[EsdtLocalRole::Burn],
+    );
+
+    let first_user = setup.first_user.clone();
+    let locked_token_amount = rust_biguint!(1_000_000_000);
+    let other_token_amount = rust_biguint!(500_000_000);
+    let expected_lp_token_amount = rust_biguint!(499_999_000);
+
+    // set the price to 1 EGLD = 2 MEX
+    let payments = vec![
+        TxTokenTransfer {
+            token_identifier: LOCKED_TOKEN_ID.to_vec(),
+            nonce: 1,
+            value: locked_token_amount.clone(),
+        },
+        TxTokenTransfer {
+            token_identifier: WEGLD_TOKEN_ID.to_vec(),
+            nonce: 0,
+            value: other_token_amount.clone(),
+        },
+    ];
+
+    // add liquidity
+    let pair_addr = setup.pair_wrapper.address_ref().clone();
+    setup
+        .b_mock
+        .execute_esdt_multi_transfer(&first_user, &setup.proxy_wrapper, &payments, |sc| {
+            sc.add_liquidity_proxy(
+                managed_address!(&pair_addr),
+                managed_biguint!(locked_token_amount.to_u64().unwrap()),
+                managed_biguint!(other_token_amount.to_u64().unwrap()),
+            );
+        })
+        .assert_ok();
+
+    setup.b_mock.check_nft_balance(
+        &first_user,
+        WRAPPED_LP_TOKEN_ID,
+        1,
+        &expected_lp_token_amount,
+        Some(&WrappedLpTokenAttributes::<DebugApi> {
+            locked_tokens: EsdtTokenPayment {
+                token_identifier: managed_token_id!(LOCKED_TOKEN_ID),
+                token_nonce: 1,
+                amount: managed_biguint!(locked_token_amount.to_u64().unwrap()),
+            },
+            lp_token_id: managed_token_id!(LP_TOKEN_ID),
+            lp_token_amount: managed_biguint!(expected_lp_token_amount.to_u64().unwrap()),
+        }),
+    );
+
+    let block_epoch = 1u64;
+    let user_balance = USER_BALANCE;
+    setup
+        .b_mock
+        .execute_query(&setup.simple_lock_wrapper, |sc| {
+            let unlock_epoch = LOCK_OPTIONS[0];
+            let lock_epochs = unlock_epoch - block_epoch;
+            let expected_energy_amount =
+                BigInt::from((user_balance) as i64) * BigInt::from(lock_epochs as i64);
+            let expected_energy = Energy::new(
+                expected_energy_amount,
+                block_epoch,
+                managed_biguint!(user_balance),
+            );
+            let actual_energy = sc.user_energy(&managed_address!(&first_user)).get();
+            assert_eq!(expected_energy, actual_energy);
+        })
+        .assert_ok();
+
+    let farm_locked_addr = setup.farm_locked_wrapper.address_ref().clone();
+
+    //////////////////////////////////////////// ENTER FARM /////////////////////////////////////
+
+    let mut current_epoch = 5;
+    setup.b_mock.set_block_epoch(current_epoch);
+
+    setup
+        .b_mock
+        .execute_esdt_transfer(
+            &first_user,
+            &setup.proxy_wrapper,
+            WRAPPED_LP_TOKEN_ID,
+            1,
+            &expected_lp_token_amount,
+            |sc| {
+                sc.enter_farm_proxy_endpoint(
+                    managed_address!(&farm_locked_addr),
+                    OptionalValue::None,
+                );
+            },
+        )
+        .assert_ok();
+
+    let expected_energy = rust_biguint!(LOCK_OPTIONS[0] - current_epoch) * USER_BALANCE;
+    setup
+        .b_mock
+        .execute_query(&setup.simple_lock_wrapper, |sc| {
+            let managed_result = sc.get_energy_amount_for_user(managed_address!(&first_user));
+            let result = to_rust_biguint(managed_result);
+            assert_eq!(result, expected_energy);
+        })
+        .assert_ok();
+
+    // check user balance
+    setup.b_mock.check_nft_balance(
+        &first_user,
+        WRAPPED_FARM_TOKEN_ID,
+        1,
+        &expected_lp_token_amount,
+        Some(&WrappedFarmTokenAttributes::<DebugApi> {
+            proxy_farming_token: EsdtTokenPayment {
+                token_identifier: managed_token_id!(WRAPPED_LP_TOKEN_ID),
+                token_nonce: 1,
+                amount: managed_biguint!(expected_lp_token_amount.to_u64().unwrap()),
+            },
+            farm_token: EsdtTokenPayment {
+                token_identifier: managed_token_id!(FARM_LOCKED_TOKEN_ID),
+                token_nonce: 1,
+                amount: managed_biguint!(expected_lp_token_amount.to_u64().unwrap()),
+            },
+        }),
+    );
+
+    // check proxy balance
+    setup
+        .b_mock
+        .check_nft_balance::<FarmTokenAttributes<DebugApi>>(
+            setup.proxy_wrapper.address_ref(),
+            FARM_LOCKED_TOKEN_ID,
+            1,
+            &expected_lp_token_amount,
+            None,
+        );
+
+    // check farm balance
+    setup.b_mock.check_esdt_balance(
+        setup.farm_locked_wrapper.address_ref(),
+        LP_TOKEN_ID,
+        &expected_lp_token_amount,
+    );
+
+    current_epoch += 5; // applies penalty on exit
+    setup.b_mock.set_block_epoch(current_epoch);
+    setup.b_mock.set_block_nonce(100);
+
+    ////////////////////////////////////////////// DESTROY FARM /////////////////////////////////////
+
+    // should be 500_000_000, but ends up so due to approximations
+    let removed_locked_token_amount = rust_biguint!(499_999_000);
+    // should be 250_000_000, but ends up so due to approximations
+    let removed_other_token_amount = rust_biguint!(249_999_500);
+    // exit with partial amount
+    setup
+        .b_mock
+        .execute_esdt_transfer(
+            &first_user,
+            &setup.proxy_wrapper,
+            WRAPPED_FARM_TOKEN_ID,
+            1,
+            &(expected_lp_token_amount.clone() / rust_biguint!(2)),
+            |sc| {
+                let output_payments = sc.destroy_farm_proxy(
+                    managed_address!(&farm_locked_addr),
+                    managed_biguint!(1),
+                    managed_biguint!(1),
+                    OptionalValue::None,
+                );
+
+                let output_vec = output_payments.to_vec();
+
+                assert_eq!(output_payments.len(), 3);
+                assert_eq!(
+                    output_vec.get(0).amount.to_u64().unwrap(),
+                    removed_locked_token_amount.to_u64().unwrap()
+                );
+                assert_eq!(
+                    output_vec.get(1).amount.to_u64().unwrap(),
+                    removed_other_token_amount.to_u64().unwrap()
+                );
+                assert_eq!(output_vec.get(2).amount.to_u64().unwrap(), 0u64);
+            },
+        )
+        .assert_ok();
+
+    // check user received half of the farm tokens back, and another new wrapped LP token
+    setup.b_mock.check_nft_balance::<Empty>(
+        &first_user,
+        WRAPPED_FARM_TOKEN_ID,
+        1,
+        &(&expected_lp_token_amount / 2u64),
+        None,
+    );
+}