Merge pull request #14 from mars-protocol/hls-params

Add HLS to asset params

contracts/params/src/emergency_powers.rs

@@ -13,7 +13,7 @@ pub fn disable_borrowing(
     OWNER.assert_emergency_owner(deps.storage, &info.sender)?;
 
     let mut params = ASSET_PARAMS.load(deps.storage, denom)?;
-    params.permissions.red_bank.borrow_enabled = false;
+    params.red_bank.borrow_enabled = false;
     ASSET_PARAMS.save(deps.storage, denom, &params)?;
 
     let response = Response::new()
@@ -31,7 +31,7 @@ pub fn disallow_coin(
     OWNER.assert_emergency_owner(deps.storage, &info.sender)?;
 
     let mut params = ASSET_PARAMS.load(deps.storage, denom)?;
-    params.permissions.rover.whitelisted = false;
+    params.rover.whitelisted = false;
     ASSET_PARAMS.save(deps.storage, denom, &params)?;
 
     let response = Response::new()

contracts/params/src/execute.rs

@@ -99,7 +99,7 @@ pub fn assert_mcf(param_value: Decimal) -> Result<(), ValidationError> {
 }
 
 /// liquidation_threshold should be greater than or equal to max_loan_to_value
-pub fn assert_lqt_gte_max_ltv(
+pub fn assert_lqt_gt_max_ltv(
     max_ltv: Decimal,
     liq_threshold: Decimal,
 ) -> Result<(), ValidationError> {
@@ -112,3 +112,17 @@ pub fn assert_lqt_gte_max_ltv(
     }
     Ok(())
 }
+
+pub fn assert_hls_lqt_gt_max_ltv(
+    max_ltv: Decimal,
+    liq_threshold: Decimal,
+) -> Result<(), ValidationError> {
+    if liq_threshold <= max_ltv {
+        return Err(ValidationError::InvalidParam {
+            param_name: "hls_liquidation_threshold".to_string(),
+            invalid_value: liq_threshold.to_string(),
+            predicate: format!("> {} (hls max LTV)", max_ltv),
+        });
+    }
+    Ok(())
+}

contracts/params/src/types.rs

@@ -2,11 +2,18 @@ use cosmwasm_schema::cw_serde;
 use cosmwasm_std::{Addr, Coin, Decimal, Uint128};
 use mars_utils::{error::ValidationError, helpers::decimal_param_le_one};
 
-use crate::execute::assert_lqt_gte_max_ltv;
+use crate::execute::{assert_hls_lqt_gt_max_ltv, assert_lqt_gt_max_ltv};
 
 #[cw_serde]
-pub struct RoverPermissions {
+pub struct HighLeverageStrategyParams {
+    pub max_loan_to_value: Decimal,
+    pub liquidation_threshold: Decimal,
+}
+
+#[cw_serde]
+pub struct RoverSettings {
     pub whitelisted: bool,
+    pub hls: HighLeverageStrategyParams,
 }
 
 #[cw_serde]
@@ -16,15 +23,10 @@ pub struct RedBankSettings {
     pub deposit_cap: Uint128,
 }
 
-#[cw_serde]
-pub struct AssetPermissions {
-    pub rover: RoverPermissions,
-    pub red_bank: RedBankSettings,
-}
-
 #[cw_serde]
 pub struct AssetParams {
-    pub permissions: AssetPermissions,
+    pub rover: RoverSettings,
+    pub red_bank: RedBankSettings,
     pub max_loan_to_value: Decimal,
     pub liquidation_threshold: Decimal,
     pub liquidation_bonus: Decimal,
@@ -34,9 +36,16 @@ impl AssetParams {
     pub fn validate(&self) -> Result<(), ValidationError> {
         decimal_param_le_one(self.max_loan_to_value, "max_loan_to_value")?;
         decimal_param_le_one(self.liquidation_threshold, "liquidation_threshold")?;
+        assert_lqt_gt_max_ltv(self.max_loan_to_value, self.liquidation_threshold)?;
+
         decimal_param_le_one(self.liquidation_bonus, "liquidation_bonus")?;
 
-        assert_lqt_gte_max_ltv(self.max_loan_to_value, self.liquidation_threshold)?;
+        decimal_param_le_one(self.rover.hls.max_loan_to_value, "hls_max_loan_to_value")?;
+        decimal_param_le_one(self.rover.hls.liquidation_threshold, "hls_liquidation_threshold")?;
+        assert_hls_lqt_gt_max_ltv(
+            self.rover.hls.max_loan_to_value,
+            self.rover.hls.liquidation_threshold,
+        )?;
 
         Ok(())
     }
@@ -66,7 +75,7 @@ impl VaultConfig {
     pub fn validate(&self) -> Result<(), ValidationError> {
         decimal_param_le_one(self.max_loan_to_value, "max_loan_to_value")?;
         decimal_param_le_one(self.liquidation_threshold, "liquidation_threshold")?;
-        assert_lqt_gte_max_ltv(self.max_loan_to_value, self.liquidation_threshold)?;
+        assert_lqt_gt_max_ltv(self.max_loan_to_value, self.liquidation_threshold)?;
         Ok(())
     }
 }

contracts/params/tests/helpers/generator.rs

@@ -2,21 +2,23 @@ use std::str::FromStr;
 
 use cosmwasm_std::{coin, Decimal, Uint128};
 use mars_params::types::{
-    AssetParams, AssetPermissions, RedBankSettings, RoverPermissions, VaultConfig,
+    AssetParams, HighLeverageStrategyParams, RedBankSettings, RoverSettings, VaultConfig,
 };
 
 pub fn default_asset_params() -> AssetParams {
     AssetParams {
-        permissions: AssetPermissions {
-            rover: RoverPermissions {
-                whitelisted: false,
-            },
-            red_bank: RedBankSettings {
-                deposit_enabled: true,
-                borrow_enabled: false,
-                deposit_cap: Uint128::new(1_000_000_000),
+        rover: RoverSettings {
+            whitelisted: false,
+            hls: HighLeverageStrategyParams {
+                max_loan_to_value: Decimal::from_str("0.85").unwrap(),
+                liquidation_threshold: Decimal::from_str("0.9").unwrap(),
             },
         },
+        red_bank: RedBankSettings {
+            deposit_enabled: true,
+            borrow_enabled: false,
+            deposit_cap: Uint128::new(1_000_000_000),
+        },
         max_loan_to_value: Decimal::from_str("0.6").unwrap(),
         liquidation_threshold: Decimal::from_str("0.7").unwrap(),
         liquidation_bonus: Decimal::from_str("0.15").unwrap(),

contracts/params/tests/test_asset_validation.rs

@@ -98,7 +98,7 @@ fn liquidation_bonus_less_than_or_equal_to_one() {
 }
 
 #[test]
-fn liq_threshold_gte_max_ltv() {
+fn liq_threshold_gt_max_ltv() {
     let mut mock = MockEnv::new().build().unwrap();
     let mut params = default_asset_params();
     params.liquidation_threshold = Decimal::from_str("0.5").unwrap();
@@ -120,3 +120,73 @@ fn liq_threshold_gte_max_ltv() {
         }),
     );
 }
+
+#[test]
+fn hls_max_ltv_less_than_or_equal_to_one() {
+    let mut mock = MockEnv::new().build().unwrap();
+    let mut params = default_asset_params();
+    params.rover.hls.max_loan_to_value = Decimal::from_str("1.1235").unwrap();
+
+    let res = mock.update_asset_params(
+        &mock.query_owner(),
+        AssetParamsUpdate::AddOrUpdate {
+            denom: "denom_xyz".to_string(),
+            params,
+        },
+    );
+    assert_err(
+        res,
+        Validation(InvalidParam {
+            param_name: "hls_max_loan_to_value".to_string(),
+            invalid_value: "1.1235".to_string(),
+            predicate: "<= 1".to_string(),
+        }),
+    );
+}
+
+#[test]
+fn hls_liquidation_threshold_less_than_or_equal_to_one() {
+    let mut mock = MockEnv::new().build().unwrap();
+    let mut params = default_asset_params();
+    params.rover.hls.liquidation_threshold = Decimal::from_str("1.1235").unwrap();
+
+    let res = mock.update_asset_params(
+        &mock.query_owner(),
+        AssetParamsUpdate::AddOrUpdate {
+            denom: "denom_xyz".to_string(),
+            params,
+        },
+    );
+    assert_err(
+        res,
+        Validation(InvalidParam {
+            param_name: "hls_liquidation_threshold".to_string(),
+            invalid_value: "1.1235".to_string(),
+            predicate: "<= 1".to_string(),
+        }),
+    );
+}
+
+#[test]
+fn hls_liq_threshold_gt_hls_max_ltv() {
+    let mut mock = MockEnv::new().build().unwrap();
+    let mut params = default_asset_params();
+    params.rover.hls.liquidation_threshold = Decimal::from_str("0.5").unwrap();
+    params.rover.hls.max_loan_to_value = Decimal::from_str("0.6").unwrap();
+
+    let res = mock.update_asset_params(
+        &mock.query_owner(),
+        AssetParamsUpdate::AddOrUpdate {
+            denom: "denom_xyz".to_string(),
+            params,
+        },
+    );
+    assert_err(
+        res,
+        Validation(InvalidParam {
+            param_name: "hls_liquidation_threshold".to_string(),
+            invalid_value: "0.5".to_string(),
+            predicate: "> 0.6 (hls max LTV)".to_string(),
+        }),
+    );
+}

contracts/params/tests/test_emergency_powers.rs

@@ -48,7 +48,7 @@ fn disabling_borrowing() {
     let denom = "atom".to_string();
 
     let mut params = default_asset_params();
-    params.permissions.red_bank.borrow_enabled = true;
+    params.red_bank.borrow_enabled = true;
 
     mock.update_asset_params(
         &mock.query_owner(),
@@ -60,7 +60,7 @@ fn disabling_borrowing() {
     .unwrap();
 
     let params = mock.query_asset_params(&denom);
-    assert!(params.permissions.red_bank.borrow_enabled);
+    assert!(params.red_bank.borrow_enabled);
 
     mock.emergency_update(
         &emergency_owner,
@@ -69,7 +69,7 @@ fn disabling_borrowing() {
     .unwrap();
 
     let params = mock.query_asset_params(&denom);
-    assert!(!params.permissions.red_bank.borrow_enabled);
+    assert!(!params.red_bank.borrow_enabled);
 }
 
 #[test]
@@ -79,7 +79,7 @@ fn disallow_coin() {
     let denom = "atom".to_string();
 
     let mut params = default_asset_params();
-    params.permissions.rover.whitelisted = true;
+    params.rover.whitelisted = true;
 
     mock.update_asset_params(
         &mock.query_owner(),
@@ -91,7 +91,7 @@ fn disallow_coin() {
     .unwrap();
 
     let params = mock.query_asset_params(&denom);
-    assert!(params.permissions.rover.whitelisted);
+    assert!(params.rover.whitelisted);
 
     mock.emergency_update(
         &emergency_owner,
@@ -100,7 +100,7 @@ fn disallow_coin() {
     .unwrap();
 
     let params = mock.query_asset_params(&denom);
-    assert!(!params.permissions.rover.whitelisted);
+    assert!(!params.rover.whitelisted);
 }
 
 #[test]

contracts/params/tests/test_update_asset_params.rs

@@ -51,22 +51,13 @@ fn initializing_asset_param() {
     assert_eq!(&denom0, &res.denom);
 
     // Validate config set correctly
-    assert_eq!(params.permissions.rover.whitelisted, res.params.permissions.rover.whitelisted);
-    assert_eq!(
-        params.permissions.red_bank.deposit_enabled,
-        res.params.permissions.red_bank.deposit_enabled
-    );
-    assert_eq!(
-        params.permissions.red_bank.borrow_enabled,
-        res.params.permissions.red_bank.borrow_enabled
-    );
+    assert_eq!(params.rover.whitelisted, res.params.rover.whitelisted);
+    assert_eq!(params.red_bank.deposit_enabled, res.params.red_bank.deposit_enabled);
+    assert_eq!(params.red_bank.borrow_enabled, res.params.red_bank.borrow_enabled);
     assert_eq!(params.max_loan_to_value, res.params.max_loan_to_value);
     assert_eq!(params.liquidation_threshold, res.params.liquidation_threshold);
     assert_eq!(params.liquidation_bonus, res.params.liquidation_bonus);
-    assert_eq!(
-        params.permissions.red_bank.deposit_cap,
-        res.params.permissions.red_bank.deposit_cap
-    );
+    assert_eq!(params.red_bank.deposit_cap, res.params.red_bank.deposit_cap);
 
     mock.update_asset_params(
         &owner,
@@ -144,11 +135,11 @@ fn update_existing_asset_params() {
     .unwrap();
 
     let asset_params = mock.query_asset_params(&denom0);
-    assert!(!asset_params.permissions.rover.whitelisted);
-    assert!(asset_params.permissions.red_bank.deposit_enabled);
+    assert!(!asset_params.rover.whitelisted);
+    assert!(asset_params.red_bank.deposit_enabled);
 
-    params.permissions.rover.whitelisted = true;
-    params.permissions.red_bank.deposit_enabled = false;
+    params.rover.whitelisted = true;
+    params.red_bank.deposit_enabled = false;
 
     mock.update_asset_params(
         &owner,
@@ -163,8 +154,8 @@ fn update_existing_asset_params() {
     assert_eq!(1, all_asset_params.len());
 
     let asset_params = mock.query_asset_params(&denom0);
-    assert!(asset_params.permissions.rover.whitelisted);
-    assert!(!asset_params.permissions.red_bank.deposit_enabled);
+    assert!(asset_params.rover.whitelisted);
+    assert!(!asset_params.red_bank.deposit_enabled);
 }
 
 #[test]

contracts/params/tests/test_vault_validation.rs

@@ -75,7 +75,7 @@ fn vault_liquidation_threshold_less_than_or_equal_to_one() {
 }
 
 #[test]
-fn vault_liq_threshold_gte_max_ltv() {
+fn vault_liq_threshold_gt_max_ltv() {
     let mut mock = MockEnv::new().build().unwrap();
     let mut config = default_vault_config();
     config.liquidation_threshold = Decimal::from_str("0.5").unwrap();