EMode (1)

contracts/suilend/sources/lending_market.move

@@ -378,6 +378,26 @@ module suilend::lending_market {
         coin::from_balance(receive_balance, ctx)
     }
 
+    /// Set emode for obligation - T is the deposit coin type
+    public fun set_emode<P>(
+        lending_market: &mut LendingMarket<P>,
+        obligation_owner_cap: &ObligationOwnerCap<P>,
+        clock: &Clock
+    ) {
+        assert!(lending_market.version == CURRENT_VERSION, EIncorrectVersion);
+
+        let obligation = object_table::borrow_mut(
+            &mut lending_market.obligations, 
+            obligation_owner_cap.obligation_id
+        );
+
+        obligation::set_emode(
+            obligation,
+            &mut lending_market.reserves,
+            clock,
+        );
+    }
+
     public fun withdraw_ctokens<P, T>(
         lending_market: &mut LendingMarket<P>,
         reserve_array_index: u64,

contracts/suilend/sources/obligation.move

@@ -8,14 +8,18 @@ module suilend::obligation {
     use sui::tx_context::{TxContext};
     use suilend::reserve::{Self, Reserve, config};
     use suilend::reserve_config::{
+        Self,
         open_ltv, 
         close_ltv, 
         borrow_weight, 
         liquidation_bonus, 
         protocol_liquidation_fee,
         isolated,
+        open_ltv_emode,
+        close_ltv_emode,
     };
     use sui::clock::{Clock};
+    use sui::dynamic_field::{Self as df};
     use suilend::decimal::{Self, Decimal, mul, add, sub, div, gt, lt, min, floor, le, eq, saturating_sub};
     use suilend::liquidity_mining::{Self, UserRewardManager, PoolRewardManager};
 
@@ -29,12 +33,20 @@ module suilend::obligation {
     const ETooManyBorrows: u64 = 6;
     const EObligationIsNotForgivable: u64 = 7;
     const ECannotDepositAndBorrowSameAsset: u64 = 8;
+    const EEModeNotValidWithCrossMargin: u64 = 9;
+    const ENoEmodeConfigForGivenDepositReserve : u64 = 10;
+    const EInvalidEModeDeposit: u64 = 13;
+    const EInvalidEModeBorrow: u64 = 14;
+    const EEModeAlreadySet: u64 = 15;
 
     // === Constants ===
     const CLOSE_FACTOR_PCT: u8 = 20;
     const MAX_DEPOSITS: u64 = 5;
     const MAX_BORROWS: u64 = 5;
 
+    // === Dynamic Field Keys ===
+    public struct EModeFlag has store, copy, drop {}
+
     // === public structs ===
     public struct Obligation<phantom P> has key, store {
         id: UID,
@@ -157,6 +169,19 @@ module suilend::obligation {
         }
     }
 
+    public(package) fun set_emode<P>(
+        obligation: &mut Obligation<P>,
+        reserves: &mut vector<Reserve<P>>,
+        clock: &Clock,
+    ) {
+        assert!(!is_emode(obligation), EEModeAlreadySet);
+        assert!(vector::length(&obligation.borrows) <= 1, EEModeNotValidWithCrossMargin);
+        assert!(vector::length(&obligation.deposits) <= 1, EEModeNotValidWithCrossMargin);
+
+        refresh(obligation, reserves, clock);
+
+        df::add(&mut obligation.id, EModeFlag {}, true);
+    }
 
     /// update the obligation's borrowed amounts and health values. this is 
     /// called by the lending market prior to any borrow, withdraw, or liquidate operation.
@@ -169,7 +194,11 @@ module suilend::obligation {
         let mut deposited_value_usd = decimal::from(0);
         let mut allowed_borrow_value_usd = decimal::from(0);
         let mut unhealthy_borrow_value_usd = decimal::from(0);
+        let is_emode = is_emode(obligation);
+        if (is_emode) {
+            obligation.refresh_emode(reserves, is_emode, clock)
 
+        } else {
         while (i < vector::length(&obligation.deposits)) {
             let deposit = vector::borrow_mut(&mut obligation.deposits, i);
 
@@ -260,6 +289,126 @@ module suilend::obligation {
         obligation.weighted_borrowed_value_usd = weighted_borrowed_value_usd;
         obligation.weighted_borrowed_value_upper_bound_usd = weighted_borrowed_value_upper_bound_usd;
 
+        obligation.borrowing_isolated_asset = borrowing_isolated_asset;
+        };
+    }
+
+    fun refresh_emode<P>(
+        obligation: &mut Obligation<P>,
+        reserves: &mut vector<Reserve<P>>,
+        is_emode: bool,
+        clock: &Clock
+    ) {
+        let mut i = 0;
+        let mut deposited_value_usd = decimal::from(0);
+        let mut allowed_borrow_value_usd = decimal::from(0);
+        let mut unhealthy_borrow_value_usd = decimal::from(0);
+
+        while (i < vector::length(&obligation.deposits)) {
+            let deposit = vector::borrow_mut(&mut obligation.deposits, i);
+
+            let deposit_reserve = vector::borrow_mut(reserves, deposit.reserve_array_index);
+
+            reserve::compound_interest(deposit_reserve, clock);
+            reserve::assert_price_is_fresh(deposit_reserve, clock);
+
+            let market_value = reserve::ctoken_market_value(
+                deposit_reserve,
+                deposit.deposited_ctoken_amount
+            );
+            let market_value_lower_bound = reserve::ctoken_market_value_lower_bound(
+                deposit_reserve,
+                deposit.deposited_ctoken_amount
+            );
+
+            deposit.market_value = market_value;
+            deposited_value_usd = add(deposited_value_usd, market_value);
+
+            let (open_ltv, close_ltv) = get_ltvs(
+                obligation,
+                deposit_reserve,
+                is_emode,
+            );
+
+            allowed_borrow_value_usd = add(
+                allowed_borrow_value_usd,
+                mul(
+                    market_value_lower_bound,
+                    open_ltv,
+                ),
+            );
+
+            unhealthy_borrow_value_usd = add(
+                unhealthy_borrow_value_usd,
+                mul(
+                    market_value,
+                    close_ltv,
+                ),
+            );
+
+            i = i + 1;
+        };
+
+        obligation.deposited_value_usd = deposited_value_usd;
+        obligation.allowed_borrow_value_usd = allowed_borrow_value_usd;
+        obligation.unhealthy_borrow_value_usd = unhealthy_borrow_value_usd;
+
+        let mut i = 0;
+        let mut unweighted_borrowed_value_usd = decimal::from(0);
+        let mut weighted_borrowed_value_usd = decimal::from(0);
+        let mut weighted_borrowed_value_upper_bound_usd = decimal::from(0);
+        let mut borrowing_isolated_asset = false;
+
+        while (i < vector::length(&obligation.borrows)) {
+            let borrow = vector::borrow_mut(&mut obligation.borrows, i);
+
+            let borrow_reserve = vector::borrow_mut(reserves, borrow.reserve_array_index);
+            reserve::compound_interest(borrow_reserve, clock);
+            reserve::assert_price_is_fresh(borrow_reserve, clock);
+
+            compound_debt(borrow, borrow_reserve);
+
+            let market_value = reserve::market_value(borrow_reserve, borrow.borrowed_amount);
+            let market_value_upper_bound = reserve::market_value_upper_bound(
+                borrow_reserve, 
+                borrow.borrowed_amount
+            );
+
+            borrow.market_value = market_value;
+            unweighted_borrowed_value_usd = add(unweighted_borrowed_value_usd, market_value);
+
+            let borrow_weight = if (is_emode) {
+                decimal::from(1)
+            } else {
+                borrow_weight(config(borrow_reserve))
+            };
+
+            weighted_borrowed_value_usd = add(
+                weighted_borrowed_value_usd,
+                mul(
+                    market_value,
+                    borrow_weight
+                )
+            );
+            weighted_borrowed_value_upper_bound_usd = add(
+                weighted_borrowed_value_upper_bound_usd,
+                mul(
+                    market_value_upper_bound,
+                    borrow_weight
+                )
+            );
+
+            if (isolated(config(borrow_reserve))) {
+                borrowing_isolated_asset = true;
+            };
+
+            i = i + 1;
+        };
+
+        obligation.unweighted_borrowed_value_usd = unweighted_borrowed_value_usd;
+        obligation.weighted_borrowed_value_usd = weighted_borrowed_value_usd;
+        obligation.weighted_borrowed_value_upper_bound_usd = weighted_borrowed_value_upper_bound_usd;
+
         obligation.borrowing_isolated_asset = borrowing_isolated_asset;
     }
 
@@ -1221,4 +1370,57 @@ module suilend::obligation {
             user_reward_manager_index
         }
     }
-}
+
+    fun get_ltvs<P>(
+        obligation: &Obligation<P>,
+        deposit_reserve: &Reserve<P>,
+        is_emode: bool,
+    ): (Decimal, Decimal) {
+        if (is_emode) {
+            // check_normal_ltv_against_emode_ltvs
+            let borrow_reserve_index = get_single_borrow_array_reserve_if_any(obligation);
+
+            assert!(
+                reserve_config::has_emode_config(config(deposit_reserve)),
+                ENoEmodeConfigForGivenDepositReserve,
+            );
+
+            if (option::is_none(&borrow_reserve_index)) {
+                // When obligation is emode but there is no borrows
+                (open_ltv(config(deposit_reserve)), close_ltv(config(deposit_reserve)))
+            } else {
+                // When obligation is emode and there is a borrow
+                let emode_entry = reserve_config::try_get_emode_entry(
+                    config(deposit_reserve),
+                    option::borrow(&borrow_reserve_index)
+                );
+
+                if (option::is_some(&emode_entry)) {
+                    // When obligation is emode and there is a borrow AND there is a matching emode config
+                    (open_ltv_emode(option::borrow(&emode_entry)), close_ltv_emode(option::borrow(&emode_entry)))
+                } else {
+                    // When obligation is emode and there is a borrow BUT there is no matching emode config
+                    (open_ltv(config(deposit_reserve)), close_ltv(config(deposit_reserve)))
+                }
+        }
+        } else {
+            // When obligation normal mode
+            (open_ltv(config(deposit_reserve)), close_ltv(config(deposit_reserve)))
+        }
+    }
+
+    fun is_emode<P>(obligation: &Obligation<P>): bool {
+        df::exists_(&obligation.id, EModeFlag {})
+    }
+
+    fun get_single_borrow_array_reserve_if_any<P>(
+        obligation: &Obligation<P>,
+    ): Option<u64> {
+        let len = vector::length(&obligation.borrows);
+        if (len != 1) {
+            option::none()
+        } else {
+            option::some(vector::borrow(&obligation.borrows, 0).reserve_array_index)
+        }
+    }
+}