lending: Use fair obligation health factor calculation (#1119)

* lending: Use fair health factor calulation and handle dust

* ci: fix github action caching

Author: jstarry

.github/workflows/pull-request.yml

@@ -109,16 +109,12 @@ jobs:
           path: |
             ~/.cargo/bin/rustfilt
           key: cargo-bpf-bins-${{ runner.os }}
-          restore-keys: |
-            cargo-bpf-bins-${{ runner.os }}-
 
       - uses: actions/cache@v2
         with:
           path: |
             ~/.cache
           key: solana-${{ env.SOLANA_VERSION }}
-          restore-keys: |
-            solana-
 
       - name: Install dependencies
         run: |

ci/cargo-build-test.sh

@@ -4,7 +4,7 @@ set -e
 cd "$(dirname "$0")/.."
 
 source ./ci/rust-version.sh stable
-source ./ci/solana-version.sh install
+source ./ci/solana-version.sh
 
 export RUSTFLAGS="-D warnings"
 export RUSTBACKTRACE=1

ci/solana-version.sh

@@ -14,17 +14,17 @@
 if [[ -n $SOLANA_VERSION ]]; then
   solana_version="$SOLANA_VERSION"
 else
-  solana_version=v1.5.0
+  solana_version=v1.5.5
 fi
 
 export solana_version="$solana_version"
 export solana_docker_image=solanalabs/solana:"$solana_version"
+export PATH="$HOME"/.local/share/solana/install/active_release/bin:"$PATH"
 
 if [[ -n $1 ]]; then
   case $1 in
   install)
     sh -c "$(curl -sSfL https://release.solana.com/$solana_version/install)"
-    export PATH="$HOME"/.local/share/solana/install/active_release/bin:"$PATH"
     solana --version
     ;;
   *)

token-lending/program/src/dex_market.rs

@@ -6,7 +6,7 @@ use crate::{
     state::TokenConverter,
 };
 use arrayref::{array_refs, mut_array_refs};
-use serum_dex::critbit::Slab;
+use serum_dex::critbit::{Slab, SlabView};
 use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
 use std::{cell::RefMut, convert::TryFrom};
 
@@ -59,6 +59,43 @@ pub struct TradeSimulator<'a> {
 }
 
 impl<'a> TokenConverter for TradeSimulator<'a> {
+    fn best_price(&mut self, token_mint: &Pubkey) -> Result<Decimal, ProgramError> {
+        let action = if token_mint == self.buy_token_mint {
+            TradeAction::Buy
+        } else {
+            TradeAction::Sell
+        };
+
+        let currency = if token_mint == self.quote_token_mint {
+            Currency::Quote
+        } else {
+            Currency::Base
+        };
+
+        let order_book_side = match (action, currency) {
+            (TradeAction::Buy, Currency::Base) => Side::Ask,
+            (TradeAction::Sell, Currency::Quote) => Side::Ask,
+            (TradeAction::Buy, Currency::Quote) => Side::Bid,
+            (TradeAction::Sell, Currency::Base) => Side::Bid,
+        };
+        if order_book_side != self.orders_side {
+            return Err(LendingError::DexInvalidOrderBookSide.into());
+        }
+
+        let best_order_price = self
+            .orders
+            .best_order_price()
+            .ok_or(LendingError::TradeSimulationError)?;
+
+        let input_token = Decimal::one().try_div(self.dex_market.get_lots(currency))?;
+        let output_token_price = if currency == Currency::Base {
+            input_token.try_mul(best_order_price)
+        } else {
+            input_token.try_div(best_order_price)
+        }?;
+        Ok(output_token_price.try_mul(self.dex_market.get_lots(currency.opposite()))?)
+    }
+
     fn convert(
         self,
         from_amount: Decimal,
@@ -200,6 +237,18 @@ impl<'a> DexMarketOrders<'a> {
 
         Ok(Self { heap, side })
     }
+
+    fn best_order_price(&mut self) -> Option<u64> {
+        let side = self.side;
+        self.heap.as_mut().and_then(|heap| {
+            let handle = match side {
+                Side::Bid => heap.find_max(),
+                Side::Ask => heap.find_min(),
+            }?;
+
+            Some(heap.get_mut(handle)?.as_leaf_mut()?.price().get())
+        })
+    }
 }
 
 impl Iterator for DexMarketOrders<'_> {

token-lending/program/src/error.rs

@@ -7,6 +7,7 @@ use thiserror::Error;
 /// Errors that may be returned by the TokenLending program.
 #[derive(Clone, Debug, Eq, Error, FromPrimitive, PartialEq)]
 pub enum LendingError {
+    // 0
     /// Invalid instruction data passed in.
     #[error("Failed to unpack instruction data")]
     InstructionUnpackError,
@@ -22,6 +23,8 @@ pub enum LendingError {
     /// Expected a different market owner
     #[error("Market owner is invalid")]
     InvalidMarketOwner,
+
+    // 5
     /// The owner of the input isn't set to the program address generated by the program.
     #[error("Input account owner is not the program address")]
     InvalidAccountOwner,
@@ -37,6 +40,8 @@ pub enum LendingError {
     /// Invalid amount, must be greater than zero
     #[error("Input amount is invalid")]
     InvalidAmount,
+
+    // 10
     /// Invalid config value
     #[error("Input config value is invalid")]
     InvalidConfig,
@@ -53,6 +58,7 @@ pub enum LendingError {
     #[error("Interest rate is negative")]
     NegativeInterestRate,
 
+    // 15
     /// Memory is too small
     #[error("Memory is too small")]
     MemoryTooSmall,
@@ -68,6 +74,8 @@ pub enum LendingError {
     /// Insufficient liquidity available
     #[error("Insufficient liquidity available")]
     InsufficientLiquidity,
+
+    // 20
     /// This reserve's collateral cannot be used for borrows
     #[error("Input reserve has collateral disabled")]
     ReserveCollateralDisabled,
@@ -77,12 +85,14 @@ pub enum LendingError {
     /// Input reserves cannot use the same liquidity mint
     #[error("Input reserves cannot use the same liquidity mint")]
     DuplicateReserveMint,
-    /// Obligation amount is too small to pay off
-    #[error("Obligation amount is too small to pay off")]
-    ObligationTooSmall,
+    /// Obligation amount is empty
+    #[error("Obligation amount is empty")]
+    ObligationEmpty,
     /// Cannot liquidate healthy obligations
     #[error("Cannot liquidate healthy obligations")]
     HealthyObligation,
+
+    // 25
     /// Borrow amount too small
     #[error("Borrow amount too small")]
     BorrowTooSmall,
@@ -92,14 +102,14 @@ pub enum LendingError {
     /// Reserve state stale
     #[error("Reserve state needs to be updated for the current slot")]
     ReserveStale,
-
     /// Trade simulation error
     #[error("Trade simulation error")]
     TradeSimulationError,
     /// Invalid dex order book side
     #[error("Invalid dex order book side")]
     DexInvalidOrderBookSide,
 
+    // 30
     /// Token initialize mint failed
     #[error("Token initialize mint failed")]
     TokenInitializeMintFailed,

token-lending/program/src/processor.rs

@@ -871,6 +871,9 @@ fn process_repay(
         msg!("Invalid withdraw reserve account");
         return Err(LendingError::InvalidAccountInput.into());
     }
+    if obligation.deposited_collateral_tokens == 0 {
+        return Err(LendingError::ObligationEmpty.into());
+    }
 
     let obligation_mint = unpack_mint(&obligation_token_mint_info.data.borrow())?;
     if &obligation.token_mint != obligation_token_mint_info.key {
@@ -1030,6 +1033,9 @@ fn process_liquidate(
         msg!("Invalid withdraw reserve account");
         return Err(LendingError::InvalidAccountInput.into());
     }
+    if obligation.deposited_collateral_tokens == 0 {
+        return Err(LendingError::ObligationEmpty.into());
+    }
 
     let mut repay_reserve = Reserve::unpack(&repay_reserve_info.data.borrow())?;
     if repay_reserve_info.owner != program_id {
@@ -1104,7 +1110,6 @@ fn process_liquidate(
     )?;
 
     let LiquidateResult {
-        bonus_amount,
         withdraw_amount,
         repay_amount,
         settle_amount,
@@ -1118,7 +1123,7 @@ fn process_liquidate(
     repay_reserve.liquidity.repay(repay_amount, settle_amount)?;
     Reserve::pack(repay_reserve, &mut repay_reserve_info.data.borrow_mut())?;
 
-    obligation.liquidate(settle_amount, withdraw_amount, bonus_amount)?;
+    obligation.liquidate(settle_amount, withdraw_amount)?;
     Obligation::pack(obligation, &mut obligation_info.data.borrow_mut())?;
 
     let authority_signer_seeds = &[
@@ -1151,18 +1156,6 @@ fn process_liquidate(
         token_program: token_program_id.clone(),
     })?;
 
-    // pay bonus collateral
-    if bonus_amount > 0 {
-        spl_token_transfer(TokenTransferParams {
-            source: withdraw_reserve_collateral_supply_info.clone(),
-            destination: destination_collateral_info.clone(),
-            amount: bonus_amount,
-            authority: lending_market_authority_info.clone(),
-            authority_signer_seeds,
-            token_program: token_program_id.clone(),
-        })?;
-    }
-
     Ok(())
 }
 

token-lending/program/src/state/mod.rs

@@ -34,6 +34,9 @@ pub const SLOTS_PER_YEAR: u64 =
 
 /// Token converter
 pub trait TokenConverter {
+    /// Return best price for specified token
+    fn best_price(&mut self, token_mint: &Pubkey) -> Result<Decimal, ProgramError>;
+
     /// Convert between two different tokens
     fn convert(
         self,

token-lending/program/src/state/obligation.rs

@@ -52,6 +52,37 @@ impl Obligation {
         }
     }
 
+    /// Maximum amount of loan that can be closed out by a liquidator due
+    /// to the remaining balance being too small to be liquidated normally.
+    pub fn max_closeable_amount(&self) -> Result<u64, ProgramError> {
+        if self.borrowed_liquidity_wads < Decimal::from(CLOSEABLE_AMOUNT) {
+            self.borrowed_liquidity_wads.try_ceil_u64()
+        } else {
+            Ok(0)
+        }
+    }
+
+    /// Maximum amount of loan that can be repaid by liquidators
+    pub fn max_liquidation_amount(&self) -> Result<u64, ProgramError> {
+        Ok(self
+            .borrowed_liquidity_wads
+            .try_mul(Rate::from_percent(LIQUIDATION_CLOSE_FACTOR))?
+            .try_floor_u64()?)
+    }
+
+    /// Ratio of loan balance to collateral value
+    pub fn loan_to_value(
+        &self,
+        collateral_exchange_rate: CollateralExchangeRate,
+        borrow_token_price: Decimal,
+    ) -> Result<Decimal, ProgramError> {
+        let loan = self.borrowed_liquidity_wads;
+        let collateral_value = collateral_exchange_rate
+            .decimal_collateral_to_liquidity(self.deposited_collateral_tokens.into())?
+            .try_div(borrow_token_price)?;
+        loan.try_div(collateral_value)
+    }
+
     /// Accrue interest
     pub fn accrue_interest(&mut self, cumulative_borrow_rate: Decimal) -> ProgramResult {
         if cumulative_borrow_rate < self.cumulative_borrow_rate_wads {
@@ -72,15 +103,10 @@ impl Obligation {
     }
 
     /// Liquidate part of obligation
-    pub fn liquidate(
-        &mut self,
-        settle_amount: Decimal,
-        withdraw_amount: u64,
-        bonus_amount: u64,
-    ) -> ProgramResult {
+    pub fn liquidate(&mut self, settle_amount: Decimal, withdraw_amount: u64) -> ProgramResult {
         self.borrowed_liquidity_wads = self.borrowed_liquidity_wads.try_sub(settle_amount)?;
         self.deposited_collateral_tokens
-            .checked_sub(withdraw_amount + bonus_amount)
+            .checked_sub(withdraw_amount)
             .ok_or(LendingError::MathOverflow)?;
         Ok(())
     }
@@ -95,7 +121,7 @@ impl Obligation {
             Decimal::from(liquidity_amount).min(self.borrowed_liquidity_wads);
         let integer_repay_amount = decimal_repay_amount.try_ceil_u64()?;
         if integer_repay_amount == 0 {
-            return Err(LendingError::ObligationTooSmall.into());
+            return Err(LendingError::ObligationEmpty.into());
         }
 
         let repay_pct: Decimal = decimal_repay_amount.try_div(self.borrowed_liquidity_wads)?;