fix: block user liquidations when liabilities equal collateral

Author: mootz12

pool/src/auctions/user_liquidation_auction.rs

@@ -47,7 +47,7 @@ pub fn create_user_liq_auction_data(
     let position_data = PositionData::calculate_from_positions(e, &mut pool, &user_state.positions);
 
     // ensure the user has less collateral than liabilities
-    if position_data.liability_base < position_data.collateral_base {
+    if position_data.liability_base <= position_data.collateral_base {
         panic_with_error!(e, PoolError::InvalidLiquidation);
     }
 
@@ -2413,6 +2413,101 @@ mod tests {
         });
     }
 
+    #[test]
+    #[should_panic(expected = "Error(Contract, #1211)")]
+    fn test_create_user_liquidation_requires_unhealthy_user() {
+        let e = Env::default();
+        e.cost_estimate().budget().reset_unlimited();
+
+        e.mock_all_auths();
+        e.ledger().set(LedgerInfo {
+            timestamp: 12345,
+            protocol_version: 22,
+            sequence_number: 50,
+            network_id: Default::default(),
+            base_reserve: 10,
+            min_temp_entry_ttl: 10,
+            min_persistent_entry_ttl: 10,
+            max_entry_ttl: 3110400,
+        });
+
+        let bombadil = Address::generate(&e);
+        let samwise = Address::generate(&e);
+
+        let pool_address = create_pool(&e);
+        let (oracle_address, oracle_client) = testutils::create_mock_oracle(&e);
+        let backstop_address = Address::generate(&e);
+
+        // setup reserves to make it simple to have collateral_base == liabilities_base
+        let (underlying_0, _) = testutils::create_token_contract(&e, &bombadil);
+        let (mut reserve_config_0, mut reserve_data_0) = testutils::default_reserve_meta();
+        reserve_config_0.c_factor = 1_0000000;
+        reserve_config_0.l_factor = 1_0000000;
+        reserve_data_0.last_time = 12345;
+        reserve_config_0.index = 0;
+        testutils::create_reserve(
+            &e,
+            &pool_address,
+            &underlying_0,
+            &reserve_config_0,
+            &reserve_data_0,
+        );
+
+        let (underlying_1, _) = testutils::create_token_contract(&e, &bombadil);
+        let (mut reserve_config_1, mut reserve_data_1) = testutils::default_reserve_meta();
+        reserve_config_1.c_factor = 1_0000000;
+        reserve_config_1.l_factor = 1_0000000;
+        reserve_data_1.last_time = 12345;
+        reserve_config_1.index = 1;
+        testutils::create_reserve(
+            &e,
+            &pool_address,
+            &underlying_1,
+            &reserve_config_1,
+            &reserve_data_1,
+        );
+
+        oracle_client.set_data(
+            &bombadil,
+            &Asset::Other(Symbol::new(&e, "USD")),
+            &vec![
+                &e,
+                Asset::Stellar(underlying_0.clone()),
+                Asset::Stellar(underlying_1.clone()),
+            ],
+            &7,
+            &300,
+        );
+        oracle_client.set_price_stable(&vec![&e, 2_0000000, 4_0000000]);
+
+        let liq_pct = 45;
+        let positions: Positions = Positions {
+            collateral: map![&e, (0, 10_0000000),],
+            liabilities: map![&e, (1, 5_0000000),],
+            supply: map![&e],
+        };
+        let pool_config = PoolConfig {
+            oracle: oracle_address,
+            min_collateral: 1_0000000,
+            bstop_rate: 0_1000000,
+            status: 0,
+            max_positions: 4,
+        };
+        e.as_contract(&pool_address, || {
+            storage::set_user_positions(&e, &samwise, &positions);
+            storage::set_pool_config(&e, &pool_config);
+            storage::set_backstop(&e, &backstop_address);
+
+            create_user_liq_auction_data(
+                &e,
+                &samwise,
+                &vec![&e, underlying_1.clone()],
+                &vec![&e, underlying_0.clone()],
+                liq_pct,
+            );
+        });
+    }
+
     #[test]
     fn test_fill_user_liquidation_auction() {
         let e = Env::default();