Hc liquidation price

packages/health-computer/Cargo.toml

@@ -31,6 +31,7 @@ wasm-bindgen      = { workspace = true, optional = true }
 # all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
 # code size when deploying.
 console_error_panic_hook = { version = "0.1.7", optional = true }
+web-sys = "0.3.64"
 
 [dev-dependencies]
 proptest = { workspace = true }

packages/health-computer/src/health_computer.rs

@@ -1,15 +1,16 @@
 use std::cmp::min;
 
 use cosmwasm_schema::cw_serde;
-use cosmwasm_std::{Coin, Decimal, Uint128};
+use cosmwasm_std::{Coin, Decimal, Fraction, Uint128};
 use mars_types::{
     credit_manager::Positions,
     health::{
         AccountKind, BorrowTarget, Health,
         HealthError::{
-            MissingHLSParams, MissingParams, MissingPrice, MissingVaultConfig, MissingVaultValues,
+            MissingAmount, MissingHLSParams, MissingParams, MissingPrice, MissingVaultConfig,
+            MissingVaultValues,
         },
-        HealthResult, SwapKind,
+        HealthResult, LiquidationPriceKind, SwapKind,
     },
     params::{AssetParams, CmSettings, VaultConfig},
 };
@@ -31,7 +32,7 @@ pub struct HealthComputer {
 }
 
 impl HealthComputer {
-    pub fn compute_health(&self) -> mars_types::health::HealthResult<Health> {
+    pub fn compute_health(&self) -> HealthResult<Health> {
         let CollateralValue {
             total_collateral_value,
             max_ltv_adjusted_collateral,
@@ -403,6 +404,72 @@ impl HealthComputer {
         Ok(max_borrow_amount)
     }
 
+    pub fn liquidation_price(
+        &self,
+        denom: &str,
+        kind: &LiquidationPriceKind,
+    ) -> HealthResult<Uint128> {
+        let collateral_ltv_value = self.total_collateral_value()?.max_ltv_adjusted_collateral;
+        let total_debt_value = self.total_debt_value()?;
+        if total_debt_value.is_zero() {
+            return Ok(Uint128::zero());
+        }
+
+        let current_price =
+            self.denoms_data.prices.get(denom).ok_or(MissingPrice(denom.to_string()))?;
+
+        if total_debt_value >= collateral_ltv_value {
+            return Ok(Uint128::one() * *current_price);
+        }
+
+        match kind {
+            LiquidationPriceKind::Asset => {
+                let asset_amount = self.get_coin_from_deposits_and_lends(denom)?.amount;
+                if asset_amount.is_zero() {
+                    return Err(MissingAmount(denom.to_string()));
+                }
+
+                let asset_ltv = self.get_coin_max_ltv(denom)?;
+
+                let asset_ltv_value =
+                    asset_amount.checked_mul_floor(current_price.checked_mul(asset_ltv)?)?;
+                let debt_with_asset_ltv_value = total_debt_value.checked_add(asset_ltv_value)?;
+
+                if debt_with_asset_ltv_value <= collateral_ltv_value {
+                    return Ok(Uint128::zero());
+                }
+
+                let debt_without = debt_with_asset_ltv_value - collateral_ltv_value;
+
+                // liquidation_price = (debt_value - collateral_ltv_value + asset_ltv_value) / (asset_amount * asset_ltv)
+                Ok(Uint128::one()
+                    * Decimal::checked_from_ratio(debt_without, asset_amount)?.checked_mul(
+                        Decimal::from_ratio(asset_ltv.denominator(), asset_ltv.numerator()),
+                    )?)
+            }
+
+            LiquidationPriceKind::Debt => {
+                let debt_amount = self
+                    .positions
+                    .debts
+                    .iter()
+                    .find(|c| c.denom == denom)
+                    .ok_or(MissingAmount(denom.to_string()))?
+                    .amount;
+                if debt_amount.is_zero() {
+                    return Err(MissingAmount(denom.to_string()));
+                }
+
+                // Liquidation_price = (collateral_ltv_value - total_debt_value + debt_value_asset / asset_amount
+                let debt_value = debt_amount.checked_mul_ceil(*current_price)?;
+                let net_collateral_value_without_debt =
+                    collateral_ltv_value.checked_add(debt_value)?.checked_sub(total_debt_value)?;
+
+                Ok(net_collateral_value_without_debt / debt_amount)
+            }
+        }
+    }
+
     fn total_debt_value(&self) -> HealthResult<Uint128> {
         let mut total = Uint128::zero();
         for debt in &self.positions.debts {

packages/health-computer/src/javascript.rs

@@ -1,4 +1,6 @@
-use mars_types::health::{BorrowTarget, HealthValuesResponse, Slippage, SwapKind};
+use mars_types::health::{
+    BorrowTarget, HealthValuesResponse, LiquidationPriceKind, Slippage, SwapKind,
+};
 use wasm_bindgen::prelude::*;
 
 use crate::HealthComputer;
@@ -39,3 +41,12 @@ pub fn max_swap_estimate_js(
         .unwrap()
         .to_string()
 }
+
+#[wasm_bindgen]
+pub fn liquidation_price_js(
+    c: HealthComputer,
+    denom: String,
+    kind: LiquidationPriceKind,
+) -> String {
+    c.liquidation_price(&denom, &kind).unwrap().to_string()
+}

packages/types/src/health/account.rs

@@ -50,3 +50,11 @@ impl Slippage {
         self.0
     }
 }
+
+#[cw_serde]
+#[cfg_attr(feature = "javascript", derive(Tsify))]
+#[cfg_attr(feature = "javascript", tsify(into_wasm_abi, from_wasm_abi))]
+pub enum LiquidationPriceKind {
+    Asset,
+    Debt,
+}

packages/types/src/health/error.rs

@@ -18,6 +18,9 @@ pub enum HealthError {
     #[error("{0} address has not been set in config")]
     ContractNotSet(String),
 
+    #[error("{0} amount was not provided or is 0")]
+    MissingAmount(String),
+
     #[error(
         "Account is an HLS account, but {0} was not provided HLS params to compute health with"
     )]