From 9803759e81fb54d9b8e044b9af21396346234a3f Mon Sep 17 00:00:00 2001 From: Sorin Petreasca Date: Tue, 14 May 2024 03:00:15 +0300 Subject: [PATCH 1/2] proxy dex unit tests audit update --- .../proxy_dex/tests/proxy_farm_test.rs | 422 +++++++++++++++++- locked-asset/proxy_dex/tests/proxy_lp_test.rs | 118 +++-- 2 files changed, 493 insertions(+), 47 deletions(-) diff --git a/locked-asset/proxy_dex/tests/proxy_farm_test.rs b/locked-asset/proxy_dex/tests/proxy_farm_test.rs index 6fe7c59b9..af054dc93 100644 --- a/locked-asset/proxy_dex/tests/proxy_farm_test.rs +++ b/locked-asset/proxy_dex/tests/proxy_farm_test.rs @@ -355,7 +355,8 @@ fn farm_with_wrapped_lp_test() { block_epoch, managed_biguint!(user_balance), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -1216,6 +1217,19 @@ fn total_farm_mechanism_test() { let mut block_epoch = 1; setup.b_mock.set_block_epoch(block_epoch); + // Check total farm position + setup + .b_mock + .execute_query(&setup.farm_locked_wrapper, |sc| { + let first_user_total_farm_position = + sc.get_user_total_farm_position(&managed_address!(&first_user)); + assert_eq!( + first_user_total_farm_position.total_farm_position, + managed_biguint!(0) + ); + }) + .assert_ok(); + //////////////////////////////////////////// ENTER FARM ///////////////////////////////////// setup @@ -1232,6 +1246,19 @@ fn total_farm_mechanism_test() { ) .assert_ok(); + // Check total farm position + setup + .b_mock + .execute_query(&setup.farm_locked_wrapper, |sc| { + let first_user_total_farm_position = + sc.get_user_total_farm_position(&managed_address!(&first_user)); + assert_eq!( + first_user_total_farm_position.total_farm_position, + managed_biguint!(USER_BALANCE) + ); + }) + .assert_ok(); + block_epoch += 7; setup.b_mock.set_block_epoch(block_epoch); @@ -1249,6 +1276,19 @@ fn total_farm_mechanism_test() { ) .assert_ok(); + // Check total farm position + setup + .b_mock + .execute_query(&setup.farm_locked_wrapper, |sc| { + let first_user_total_farm_position = + sc.get_user_total_farm_position(&managed_address!(&first_user)); + assert_eq!( + first_user_total_farm_position.total_farm_position, + managed_biguint!(USER_BALANCE * 2) + ); + }) + .assert_ok(); + setup.b_mock.check_nft_balance( &first_user, WRAPPED_FARM_TOKEN_ID, @@ -1304,6 +1344,19 @@ fn total_farm_mechanism_test() { ) .assert_ok(); + // Check total farm position + setup + .b_mock + .execute_query(&setup.farm_locked_wrapper, |sc| { + let first_user_total_farm_position = + sc.get_user_total_farm_position(&managed_address!(&first_user)); + assert_eq!( + first_user_total_farm_position.total_farm_position, + managed_biguint!(USER_BALANCE * 2) + ); + }) + .assert_ok(); + // check user balance setup.b_mock.check_nft_balance::( &first_user, @@ -1400,7 +1453,8 @@ fn increase_proxy_farm_lkmex_energy() { block_epoch, managed_biguint!(USER_BALANCE), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -1432,7 +1486,8 @@ fn increase_proxy_farm_lkmex_energy() { block_epoch, managed_biguint!(USER_BALANCE), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -1528,7 +1583,8 @@ fn increase_proxy_farm_proxy_lp_energy() { block_epoch, managed_biguint!(user_balance), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -1621,6 +1677,17 @@ fn increase_proxy_farm_proxy_lp_energy() { ) .assert_ok(); + // check old tokens were burned + setup + .b_mock + .check_nft_balance::>( + setup.proxy_wrapper.address_ref(), + WRAPPED_FARM_TOKEN_ID, + 4, + &rust_biguint!(0u64), + None, + ); + // check energy after // lp tokens recharged = total tokens / 4 - 500 let user_locked_tokens_in_lp = locked_token_amount.to_u64().unwrap() / 4 - 500; @@ -1638,7 +1705,8 @@ fn increase_proxy_farm_proxy_lp_energy() { block_epoch, managed_biguint!(USER_BALANCE), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -1755,7 +1823,8 @@ fn increase_proxy_farm_proxy_lp_energy_unlocked_tokens() { block_epoch, managed_biguint!(user_balance), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -1852,6 +1921,17 @@ fn increase_proxy_farm_proxy_lp_energy_unlocked_tokens() { ) .assert_ok(); + // check old tokens were burned + setup + .b_mock + .check_nft_balance::>( + setup.proxy_wrapper.address_ref(), + WRAPPED_FARM_TOKEN_ID, + 4, + &rust_biguint!(0u64), + None, + ); + // check energy after // lp tokens recharged = total tokens / 4 - 500 let user_locked_tokens_in_lp = locked_token_amount.to_u64().unwrap() / 4 - 500; @@ -1870,7 +1950,8 @@ fn increase_proxy_farm_proxy_lp_energy_unlocked_tokens() { block_epoch, managed_biguint!(USER_BALANCE), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -1971,7 +2052,7 @@ fn increase_proxy_farm_proxy_lp_energy_partially_unlocked_tokens() { }) .assert_ok(); - let mut block_epoch = 1u64; + let block_epoch = 1u64; let user_balance = USER_BALANCE; // check energy before @@ -1987,7 +2068,8 @@ fn increase_proxy_farm_proxy_lp_energy_partially_unlocked_tokens() { block_epoch, managed_biguint!(user_balance), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -2065,10 +2147,6 @@ fn increase_proxy_farm_proxy_lp_energy_partially_unlocked_tokens() { ) .assert_ok(); - ////////////////////////////// Wait for tokens to unlock ///////////////////////////////////// - block_epoch += LOCK_OPTIONS[0] / 2; - setup.b_mock.set_block_epoch(block_epoch); - //////////////////////////////////////////// INCREASE ENERGY ///////////////////////////////////// setup .b_mock @@ -2084,6 +2162,17 @@ fn increase_proxy_farm_proxy_lp_energy_partially_unlocked_tokens() { ) .assert_ok(); + // check old tokens were burned + setup + .b_mock + .check_nft_balance::>( + setup.proxy_wrapper.address_ref(), + WRAPPED_FARM_TOKEN_ID, + 4, + &rust_biguint!(0u64), + None, + ); + // check energy after // lp tokens recharged = total tokens / 4 - 500 let user_locked_tokens_in_lp = locked_token_amount.to_u64().unwrap() / 4 - 500; @@ -2102,7 +2191,8 @@ fn increase_proxy_farm_proxy_lp_energy_partially_unlocked_tokens() { block_epoch, managed_biguint!(USER_BALANCE), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -2371,3 +2461,307 @@ fn total_farm_position_migration_through_proxy_dex_test() { }) .assert_ok(); } + +#[test] +fn increase_proxy_farm_legacy_token_energy_negative_test() { + let mut setup = ProxySetup::new( + proxy_dex::contract_obj, + pair::contract_obj, + farm_with_locked_rewards::contract_obj, + energy_factory::contract_obj, + ); + let first_user = setup.first_user.clone(); + let farm_addr = setup.farm_locked_wrapper.address_ref().clone(); + + //////////////////////////////////////////// ENTER FARM ///////////////////////////////////// + + setup + .b_mock + .execute_esdt_transfer( + &first_user, + &setup.proxy_wrapper, + LEGACY_LOCKED_TOKEN_ID, + 3, + &rust_biguint!(USER_BALANCE), + |sc| { + sc.enter_farm_proxy_endpoint(managed_address!(&farm_addr), OptionalValue::None); + }, + ) + .assert_ok(); + + //////////////////////////////////////////// INCREASE ENERGY ///////////////////////////////////// + setup + .b_mock + .execute_esdt_transfer( + &first_user, + &setup.proxy_wrapper, + WRAPPED_FARM_TOKEN_ID, + 1, + &rust_biguint!(USER_BALANCE), + |sc| { + sc.increase_proxy_farm_token_energy_endpoint(LOCK_OPTIONS[1]); + }, + ) + .assert_user_error("Invalid payments"); +} + +#[test] +fn total_farm_position_migration_mechanism_test() { + let mut setup = ProxySetup::new( + proxy_dex::contract_obj, + pair::contract_obj, + farm_with_locked_rewards::contract_obj, + energy_factory::contract_obj, + ); + let first_user = setup.first_user.clone(); + let farm_addr = setup.farm_locked_wrapper.address_ref().clone(); + let user_balance = rust_biguint!(USER_BALANCE * 6); + setup + .b_mock + .set_esdt_balance(&first_user, MEX_TOKEN_ID, &user_balance); + + // user locks tokens + setup + .b_mock + .execute_esdt_transfer( + &first_user, + &setup.simple_lock_wrapper, + MEX_TOKEN_ID, + 0, + &user_balance, + |sc| { + let user_payment = sc.lock_tokens_endpoint(LOCK_OPTIONS[1], OptionalValue::None); + assert_eq!(user_payment.token_nonce, 2); + assert_eq!(user_payment.amount, managed_biguint!(USER_BALANCE * 6)); + }, + ) + .assert_ok(); + + // User enter farm 5 times before migration + setup + .b_mock + .execute_esdt_transfer( + &first_user, + &setup.proxy_wrapper, + LOCKED_TOKEN_ID, + 2, + &rust_biguint!(USER_BALANCE), + |sc| { + sc.enter_farm_proxy_endpoint(managed_address!(&farm_addr), OptionalValue::None); + }, + ) + .assert_ok(); + + setup + .b_mock + .execute_esdt_transfer( + &first_user, + &setup.proxy_wrapper, + LOCKED_TOKEN_ID, + 2, + &rust_biguint!(USER_BALANCE), + |sc| { + sc.enter_farm_proxy_endpoint(managed_address!(&farm_addr), OptionalValue::None); + }, + ) + .assert_ok(); + + setup + .b_mock + .execute_esdt_transfer( + &first_user, + &setup.proxy_wrapper, + LOCKED_TOKEN_ID, + 2, + &rust_biguint!(USER_BALANCE), + |sc| { + sc.enter_farm_proxy_endpoint(managed_address!(&farm_addr), OptionalValue::None); + }, + ) + .assert_ok(); + + setup + .b_mock + .execute_esdt_transfer( + &first_user, + &setup.proxy_wrapper, + LOCKED_TOKEN_ID, + 2, + &rust_biguint!(USER_BALANCE), + |sc| { + sc.enter_farm_proxy_endpoint(managed_address!(&farm_addr), OptionalValue::None); + }, + ) + .assert_ok(); + + setup + .b_mock + .execute_esdt_transfer( + &first_user, + &setup.proxy_wrapper, + LOCKED_TOKEN_ID, + 2, + &rust_biguint!(USER_BALANCE), + |sc| { + sc.enter_farm_proxy_endpoint(managed_address!(&farm_addr), OptionalValue::None); + }, + ) + .assert_ok(); + + // Simulate contract upgrade - total farm position is reset and migration nonce set + setup + .b_mock + .execute_tx( + &setup.owner, + &setup.farm_locked_wrapper, + &rust_biguint!(0), + |sc| { + let mut first_user_total_farm_position = + sc.get_user_total_farm_position(&managed_address!(&first_user)); + first_user_total_farm_position.total_farm_position = managed_biguint!(0u64); + + sc.user_total_farm_position(&managed_address!(&first_user)) + .set(first_user_total_farm_position); + sc.farm_position_migration_nonce().set(6u64); + }, + ) + .assert_ok(); + + setup + .b_mock + .execute_query(&setup.farm_locked_wrapper, |sc| { + let first_user_total_farm_position = + sc.get_user_total_farm_position(&managed_address!(&first_user)); + assert_eq!( + first_user_total_farm_position.total_farm_position, + managed_biguint!(0) + ); + }) + .assert_ok(); + + // User enters farm again after migration + let enter_payments = vec![ + TxTokenTransfer { + token_identifier: LOCKED_TOKEN_ID.to_vec(), + nonce: 2, + value: rust_biguint!(USER_BALANCE), + }, + TxTokenTransfer { + token_identifier: WRAPPED_FARM_TOKEN_ID.to_vec(), + nonce: 1, + value: rust_biguint!(USER_BALANCE / 2), + }, + ]; + setup + .b_mock + .execute_esdt_multi_transfer(&first_user, &setup.proxy_wrapper, &enter_payments, |sc| { + sc.enter_farm_proxy_endpoint(managed_address!(&farm_addr), OptionalValue::None); + }) + .assert_ok(); + + // Check total farm position + let mut user_total_farm_position = USER_BALANCE + (USER_BALANCE / 2); + setup + .b_mock + .execute_query(&setup.farm_locked_wrapper, |sc| { + let first_user_total_farm_position = + sc.get_user_total_farm_position(&managed_address!(&first_user)); + assert_eq!( + first_user_total_farm_position.total_farm_position, + managed_biguint!(user_total_farm_position) + ); + }) + .assert_ok(); + + // Claim rewards with half old position + setup + .b_mock + .execute_esdt_transfer( + &first_user, + &setup.proxy_wrapper, + WRAPPED_FARM_TOKEN_ID, + 2, + &rust_biguint!(USER_BALANCE / 2), + |sc| { + sc.claim_rewards_proxy(managed_address!(&farm_addr), OptionalValue::None); + }, + ) + .assert_ok(); + + // Check total farm position + user_total_farm_position += USER_BALANCE / 2; + setup + .b_mock + .execute_query(&setup.farm_locked_wrapper, |sc| { + let first_user_total_farm_position = + sc.get_user_total_farm_position(&managed_address!(&first_user)); + assert_eq!( + first_user_total_farm_position.total_farm_position, + managed_biguint!(user_total_farm_position) + ); + }) + .assert_ok(); + + // Exit farm with half old position + setup + .b_mock + .execute_esdt_transfer( + &first_user, + &setup.proxy_wrapper, + WRAPPED_FARM_TOKEN_ID, + 3, + &rust_biguint!(USER_BALANCE / 2), + |sc| { + sc.exit_farm_proxy(managed_address!(&farm_addr), OptionalValue::None); + }, + ) + .assert_ok(); + + // Total farm position stays the same + setup + .b_mock + .execute_query(&setup.farm_locked_wrapper, |sc| { + let first_user_total_farm_position = + sc.get_user_total_farm_position(&managed_address!(&first_user)); + assert_eq!( + first_user_total_farm_position.total_farm_position, + managed_biguint!(user_total_farm_position) + ); + }) + .assert_ok(); + + // Merge 2 partial old farm positions + let merge_payments = vec![ + TxTokenTransfer { + token_identifier: WRAPPED_FARM_TOKEN_ID.to_vec(), + nonce: 4, + value: rust_biguint!(USER_BALANCE / 2), + }, + TxTokenTransfer { + token_identifier: WRAPPED_FARM_TOKEN_ID.to_vec(), + nonce: 5, + value: rust_biguint!(USER_BALANCE / 4 * 3), + }, + ]; + setup + .b_mock + .execute_esdt_multi_transfer(&first_user, &setup.proxy_wrapper, &merge_payments, |sc| { + sc.merge_wrapped_farm_tokens_endpoint(managed_address!(&farm_addr)); + }) + .assert_ok(); + + // Check final total farm position + user_total_farm_position += USER_BALANCE / 2; + user_total_farm_position += USER_BALANCE / 4 * 3; + setup + .b_mock + .execute_query(&setup.farm_locked_wrapper, |sc| { + let first_user_total_farm_position = + sc.get_user_total_farm_position(&managed_address!(&first_user)); + assert_eq!( + first_user_total_farm_position.total_farm_position, + managed_biguint!(user_total_farm_position) + ); + }) + .assert_ok(); +} diff --git a/locked-asset/proxy_dex/tests/proxy_lp_test.rs b/locked-asset/proxy_dex/tests/proxy_lp_test.rs index 4dab8b14a..5d524ba3a 100644 --- a/locked-asset/proxy_dex/tests/proxy_lp_test.rs +++ b/locked-asset/proxy_dex/tests/proxy_lp_test.rs @@ -133,7 +133,8 @@ fn add_remove_liquidity_proxy_test() { block_epoch, managed_biguint!(user_balance), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -190,7 +191,8 @@ fn add_remove_liquidity_proxy_test() { block_epoch, managed_biguint!(user_balance), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -884,7 +886,8 @@ fn increase_proxy_lp_token_energy() { block_epoch, managed_biguint!(USER_BALANCE), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -904,6 +907,17 @@ fn increase_proxy_lp_token_energy() { ) .assert_ok(); + // check old tokens were burned + setup + .b_mock + .check_nft_balance::>( + setup.proxy_wrapper.address_ref(), + WRAPPED_LP_TOKEN_ID, + 1, + &rust_biguint!(0u64), + None, + ); + // chceck new wrapped lp token setup.b_mock.check_nft_balance( &first_user, @@ -936,7 +950,8 @@ fn increase_proxy_lp_token_energy() { block_epoch, managed_biguint!(USER_BALANCE), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -1027,18 +1042,17 @@ fn increase_proxy_lp_token_energy_unlocked_tokens() { block_epoch, managed_biguint!(USER_BALANCE), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); - // Wait for tokens to unlock block_epoch += LOCK_OPTIONS[0]; setup.b_mock.set_block_epoch(block_epoch); - // call increase energy setup .b_mock @@ -1054,7 +1068,7 @@ fn increase_proxy_lp_token_energy_unlocked_tokens() { ) .assert_ok(); - // chceck new wrapped lp token + // check new wrapped lp token setup.b_mock.check_nft_balance( &first_user, WRAPPED_LP_TOKEN_ID, @@ -1072,22 +1086,36 @@ fn increase_proxy_lp_token_energy_unlocked_tokens() { }), ); + // check old tokens were burned + setup + .b_mock + .check_nft_balance::>( + setup.proxy_wrapper.address_ref(), + WRAPPED_LP_TOKEN_ID, + 1, + &rust_biguint!(0u64), + None, + ); + // check user energy after setup .b_mock .execute_query(&setup.simple_lock_wrapper, |sc| { let first_lock_epochs = LOCK_OPTIONS[1] - 1u64; - let second_lock_epochs = BigInt::from(LOCK_OPTIONS[0] as i64) - BigInt::from(block_epoch as i64); + let second_lock_epochs = + BigInt::from(LOCK_OPTIONS[0] as i64) - BigInt::from(block_epoch as i64); let expected_energy_amount = BigInt::from((user_locked_tokens_in_lp) as i64) * BigInt::from(first_lock_epochs as i64) - + BigInt::from((USER_BALANCE - user_locked_tokens_in_lp) as i64) * second_lock_epochs; + + BigInt::from((USER_BALANCE - user_locked_tokens_in_lp) as i64) + * second_lock_epochs; 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(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -1163,7 +1191,7 @@ fn increase_proxy_lp_token_energy_partially_unlocked_tokens() { }), ); - let mut block_epoch = 1; + let block_epoch = 1; let user_locked_tokens_in_lp = locked_token_amount.to_u64().unwrap(); // check user energy before @@ -1178,18 +1206,12 @@ fn increase_proxy_lp_token_energy_partially_unlocked_tokens() { block_epoch, managed_biguint!(USER_BALANCE), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); - - // Wait for tokens to unlock - block_epoch += LOCK_OPTIONS[0] / 2; - - setup.b_mock.set_block_epoch(block_epoch); - - // call increase energy setup .b_mock @@ -1198,24 +1220,35 @@ fn increase_proxy_lp_token_energy_partially_unlocked_tokens() { &setup.proxy_wrapper, WRAPPED_LP_TOKEN_ID, 1, - &expected_lp_token_amount, + &(&expected_lp_token_amount / 2u64), |sc| { let _ = sc.increase_proxy_pair_token_energy_endpoint(LOCK_OPTIONS[1]); }, ) .assert_ok(); - // chceck new wrapped lp token + // check old tokens were burned + setup + .b_mock + .check_nft_balance::>( + setup.proxy_wrapper.address_ref(), + WRAPPED_LP_TOKEN_ID, + 1, + &rust_biguint!(0u64), + None, + ); + + // check remaining old wrapped lp token setup.b_mock.check_nft_balance( &first_user, WRAPPED_LP_TOKEN_ID, - 2, - &expected_lp_token_amount, + 1, + &(&expected_lp_token_amount / 2u64), Some(&WrappedLpTokenAttributes:: { locked_tokens: EsdtTokenPayment { token_identifier: managed_token_id!(LOCKED_TOKEN_ID), // Nonce increases - token_nonce: 3, + token_nonce: 1, amount: managed_biguint!(locked_token_amount.to_u64().unwrap()), }, lp_token_id: managed_token_id!(LP_TOKEN_ID), @@ -1223,29 +1256,47 @@ fn increase_proxy_lp_token_energy_partially_unlocked_tokens() { }), ); + // check new wrapped lp token + setup.b_mock.check_nft_balance( + &first_user, + WRAPPED_LP_TOKEN_ID, + 2, + &(&expected_lp_token_amount / 2u64), + Some(&WrappedLpTokenAttributes:: { + locked_tokens: EsdtTokenPayment { + token_identifier: managed_token_id!(LOCKED_TOKEN_ID), + token_nonce: 2, + amount: managed_biguint!(locked_token_amount.to_u64().unwrap() / 2u64), + }, + lp_token_id: managed_token_id!(LP_TOKEN_ID), + lp_token_amount: managed_biguint!(expected_lp_token_amount.to_u64().unwrap() / 2u64), + }), + ); + // check user energy after setup .b_mock .execute_query(&setup.simple_lock_wrapper, |sc| { let first_lock_epochs = LOCK_OPTIONS[1] - 1u64; - let second_lock_epochs = BigInt::from(LOCK_OPTIONS[0] as i64) - BigInt::from(block_epoch as i64); + let second_lock_epochs = + BigInt::from(LOCK_OPTIONS[0] as i64) - BigInt::from(block_epoch as i64); - let expected_energy_amount = BigInt::from((user_locked_tokens_in_lp) as i64) + let expected_energy_amount = BigInt::from((user_locked_tokens_in_lp / 2u64) as i64) * BigInt::from(first_lock_epochs as i64) - + BigInt::from((USER_BALANCE - user_locked_tokens_in_lp) as i64) * second_lock_epochs; + + BigInt::from((USER_BALANCE) as i64) * second_lock_epochs.clone() + - BigInt::from((user_locked_tokens_in_lp / 2u64) as i64) * second_lock_epochs; 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(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); } - - #[test] fn increase_proxy_lp_legacy_token_energy() { let mut setup = ProxySetup::new( @@ -1330,7 +1381,8 @@ fn increase_proxy_lp_legacy_token_energy() { block_epoch, managed_biguint!(USER_BALANCE), ); - let actual_energy = sc.user_energy(&managed_address!(&first_user)).get(); + let actual_energy = + sc.get_updated_energy_entry_for_user(&managed_address!(&first_user)); assert_eq!(expected_energy, actual_energy); }) .assert_ok(); @@ -1349,4 +1401,4 @@ fn increase_proxy_lp_legacy_token_energy() { }, ) .assert_error(4, "Invalid payment"); -} \ No newline at end of file +} From 55088f88a9c755561a7459df2a17be3be10b9aa2 Mon Sep 17 00:00:00 2001 From: Sorin Petreasca Date: Tue, 14 May 2024 15:33:01 +0300 Subject: [PATCH 2/2] proxy dex unit test scenario improvement --- locked-asset/proxy_dex/tests/proxy_farm_test.rs | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/locked-asset/proxy_dex/tests/proxy_farm_test.rs b/locked-asset/proxy_dex/tests/proxy_farm_test.rs index af054dc93..7f7a23b60 100644 --- a/locked-asset/proxy_dex/tests/proxy_farm_test.rs +++ b/locked-asset/proxy_dex/tests/proxy_farm_test.rs @@ -2155,7 +2155,7 @@ fn increase_proxy_farm_proxy_lp_energy_partially_unlocked_tokens() { &setup.proxy_wrapper, WRAPPED_FARM_TOKEN_ID, 4, - &(&expected_lp_token_amount / &rust_biguint!(4u64)), + &(&expected_lp_token_amount / &rust_biguint!(8u64)), |sc| { sc.increase_proxy_farm_token_energy_endpoint(LOCK_OPTIONS[1]); }, @@ -2182,10 +2182,11 @@ fn increase_proxy_farm_proxy_lp_energy_partially_unlocked_tokens() { let first_lock_epochs = LOCK_OPTIONS[1] - 1u64; let second_lock_epochs = BigInt::from(LOCK_OPTIONS[0] as i64) - BigInt::from(block_epoch as i64); - let expected_energy_amount = BigInt::from((user_locked_tokens_in_lp) as i64) + let expected_energy_amount = BigInt::from((user_locked_tokens_in_lp / 2) as i64) * BigInt::from(first_lock_epochs as i64) - + BigInt::from((USER_BALANCE - user_locked_tokens_in_lp) as i64) - * second_lock_epochs; + + BigInt::from((USER_BALANCE) as i64) * second_lock_epochs.clone() + - BigInt::from((user_locked_tokens_in_lp / 2u64) as i64) * second_lock_epochs; + let expected_energy = Energy::new( expected_energy_amount, block_epoch, @@ -2203,17 +2204,17 @@ fn increase_proxy_farm_proxy_lp_energy_partially_unlocked_tokens() { &first_user, WRAPPED_FARM_TOKEN_ID, 5, - &(&expected_lp_token_amount / &rust_biguint!(4u64)), + &(&expected_lp_token_amount / &rust_biguint!(8u64)), Some(&WrappedFarmTokenAttributes:: { proxy_farming_token: EsdtTokenPayment { token_identifier: managed_token_id!(WRAPPED_LP_TOKEN_ID), token_nonce: 3, - amount: managed_biguint!(expected_lp_token_amount.to_u64().unwrap() / 4u64), + amount: managed_biguint!(expected_lp_token_amount.to_u64().unwrap() / 8u64), }, farm_token: EsdtTokenPayment { token_identifier: managed_token_id!(FARM_LOCKED_TOKEN_ID), token_nonce: 4, - amount: managed_biguint!(expected_lp_token_amount.to_u64().unwrap() / 4u64), + amount: managed_biguint!(expected_lp_token_amount.to_u64().unwrap() / 8u64), }, }), );