final tests for base debt

Author: tonylee08

packages/margin_trading/tests/margin_manager_math_tests.move

@@ -53,6 +53,11 @@ fun test_liquidation_quote_debt_partial_ok() {
     test_liquidation_quote_debt_partial();
 }
 
+#[test]
+fun test_liquidation_base_debt_default_ok() {
+    test_liquidation_base_debt_default();
+}
+
 #[test]
 fun test_liquidation_base_debt_ok() {
     test_liquidation_base_debt();
@@ -427,7 +432,7 @@ fun test_liquidation_quote_debt_partial() {
     cleanup_margin_test(registry, admin_cap, maintainer_cap, clock, scenario);
 }
 
-fun test_liquidation_base_debt() {
+fun test_liquidation_base_debt_default() {
     let (
         mut scenario,
         clock,
@@ -509,7 +514,7 @@ fun test_liquidation_base_debt() {
     // Remaining_repay_coin = 1 - 0.3597 = 0.6403 BTC
     // The liquidator should receive 0.3492 * 1.05 = 0.36666 BTC = 1100 USD. The net profit is 0.36666 - 0.3597 = 0.00696 BTC
     // 0.00696 BTC / 0.3492 BTC = 2% reward
-    // The 0.2 BTC will be used first. 1100 - 0.2 * 3000 = 500 USD. Then the remaining 500 USD will be taken as USDC..
+    // The 0.2 BTC will be used first. 1100 - 0.2 * 3000 = 500 USD. Then the remaining 500 USD will be taken as USDC.
     let (base_coin, quote_coin, remaining_repay_coin) = mm.liquidate<BTC, USDC, BTC>(
         &registry,
         &btc_price_3000,
@@ -536,6 +541,115 @@ fun test_liquidation_base_debt() {
     cleanup_margin_test(registry, admin_cap, maintainer_cap, clock, scenario);
 }
 
+fun test_liquidation_base_debt() {
+    let (
+        mut scenario,
+        clock,
+        admin_cap,
+        maintainer_cap,
+        btc_pool_id,
+        usdc_pool_id,
+        _pool_id,
+    ) = setup_btc_usd_margin_trading();
+
+    let btc_price = build_btc_price_info_object(&mut scenario, 500, &clock);
+    let usdc_price = build_demo_usdc_price_info_object(&mut scenario, &clock);
+
+    scenario.next_tx(test_constants::user1());
+    let mut pool = scenario.take_shared<Pool<BTC, USDC>>();
+    let registry = scenario.take_shared<MarginRegistry>();
+    margin_manager::new<BTC, USDC>(&pool, &registry, &clock, scenario.ctx());
+
+    scenario.next_tx(test_constants::user1());
+    let mut mm = scenario.take_shared<MarginManager<BTC, USDC>>();
+    let usdc_pool = scenario.take_shared_by_id<MarginPool<USDC>>(usdc_pool_id);
+    let mut btc_pool = scenario.take_shared_by_id<MarginPool<BTC>>(btc_pool_id);
+
+    // Deposit 500 USDC
+    mm.deposit<BTC, USDC, USDC>(
+        &registry,
+        mint_coin<USDC>(500 * usdc_multiplier(), scenario.ctx()),
+        scenario.ctx(),
+    );
+
+    // Borrow $200 BTC (0.4 BTC). Risk ratio = (500 + 200) / 200 = 3.5
+    mm.borrow_base<BTC, USDC>(
+        &registry,
+        &mut btc_pool,
+        &btc_price,
+        &usdc_price,
+        &pool,
+        40000000,
+        &clock,
+        scenario.ctx(),
+    );
+
+    assert!(
+        mm.risk_ratio(&registry, &btc_price, &usdc_price, &pool, &btc_pool, &clock) == 3_500_000_000,
+        0,
+    );
+
+    // Now we withdraw 0.2 BTC. This should be allowed since risk ratio >= 2;
+    let withdraw_btc = mm.withdraw<BTC, USDC, BTC>(
+        &registry,
+        &btc_pool,
+        &usdc_pool,
+        &btc_price,
+        &usdc_price,
+        &pool,
+        20000000,
+        &clock,
+        scenario.ctx(),
+    );
+    withdraw_btc.burn_for_testing();
+
+    // Risk ratio is now (500 + 100) / 200 = 3.0
+    assert!(
+        mm.risk_ratio(&registry, &btc_price, &usdc_price, &pool, &btc_pool, &clock) == 3_000_000_000,
+        0,
+    );
+
+    // Perform liquidation and check rewards
+    scenario.next_tx(test_constants::liquidator());
+
+    // We now have 0.2 BTC ($440) and 500 USDC ($500), with a debt of 0.4 BTC ($880)
+    // At BTC price 2200, Risk ratio = (440 + 500) / 880 = 1.0681818 < 1.1, can liquidate
+    let repay_coin = mint_coin<BTC>(1 * btc_multiplier(), scenario.ctx());
+    let btc_price_2200 = build_btc_price_info_object(&mut scenario, 2200, &clock);
+
+    assert!(
+        mm.risk_ratio(&registry, &btc_price_2200, &usdc_price, &pool, &btc_pool, &clock) == 1_068_181_825,
+        0,
+    );
+
+    // 0.37454 BTC will be used to liquidate. 0.3636 BTC for repayment of loan, 0.01094 BTC for pool liquidation fee.
+    // Since 0.3636 BTC is used for repayment, the liquidator should receive 0.3636 * 0.02 = 0.007272 as a reward.
+    // Risk ratio after liquidation = (940 - 824 - 16) / (880 - 800) = 1.25
+    // Remaining_repay_coin = 1 - 0.37454 = 0.62546 BTC
+    // The liquidator should receive 0.3636 * 1.05 = 0.38178 BTC = 840 USD.
+    // The 0.2 BTC will be used first (0.2 BTC = 440 USD). Then the remaining 400 USD will be taken as USDC.
+    let (base_coin, quote_coin, remaining_repay_coin) = mm.liquidate<BTC, USDC, BTC>(
+        &registry,
+        &btc_price_2200,
+        &usdc_price,
+        &mut btc_pool,
+        &mut pool,
+        repay_coin,
+        &clock,
+        scenario.ctx(),
+    );
+
+    assert!(base_coin.value() == 20000000, 0); // 0.2 BTC
+    assert!(quote_coin.value() == 399999930, 0); // ~400 USDC
+    assert!(remaining_repay_coin.value() == 62545457, 0); // 0.62545457 BTC
+
+    destroy_3!(remaining_repay_coin, base_coin, quote_coin);
+    return_shared_3!(mm, usdc_pool, pool);
+    destroy_3!(btc_price, usdc_price, btc_price_2200);
+    destroy(btc_pool);
+    cleanup_margin_test(registry, admin_cap, maintainer_cap, clock, scenario);
+}
+
 /// Test liquidation with BTC/SUI pair where both assets are volatile
 /// BTC: 8 decimals, SUI: 9 decimals
 fun test_btc_sui_liquidation(error_code: u64) {